diff --git a/.buildinfo b/.buildinfo new file mode 100644 index 000000000..9f540e619 --- /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: b9ac9f931ac2c571def12ac66faea05f +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 000000000..e69de29bb diff --git a/_images/CPE_CTE_matching.png b/_images/CPE_CTE_matching.png new file mode 100644 index 000000000..5b30c4b3e Binary files /dev/null and b/_images/CPE_CTE_matching.png differ 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/fixed_range_cruise_altitude.png b/_images/fixed_range_cruise_altitude.png new file mode 100644 index 000000000..98b65e63f Binary files /dev/null and b/_images/fixed_range_cruise_altitude.png differ diff --git a/_images/fixed_range_cruise_distance.png b/_images/fixed_range_cruise_distance.png new file mode 100644 index 000000000..22c92b68a Binary files /dev/null and b/_images/fixed_range_cruise_distance.png differ diff --git a/_images/fixed_range_cruise_mass.png b/_images/fixed_range_cruise_mass.png new file mode 100644 index 000000000..47b5acb80 Binary files /dev/null and b/_images/fixed_range_cruise_mass.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/hamilton_standard.png b/_images/hamilton_standard.png new file mode 100644 index 000000000..7588ddabd Binary files /dev/null and b/_images/hamilton_standard.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/installation_loss_factor.png b/_images/installation_loss_factor.png new file mode 100644 index 000000000..06dff35fc Binary files /dev/null and b/_images/installation_loss_factor.png differ diff --git a/_images/landing.png b/_images/landing.png new file mode 100644 index 000000000..2dc5318f8 Binary files /dev/null and b/_images/landing.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/multiphase_reserve.png b/_images/multiphase_reserve.png new file mode 100644 index 000000000..40b776d4f Binary files /dev/null and b/_images/multiphase_reserve.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/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/takeoff.png b/_images/takeoff.png new file mode 100644 index 000000000..2e73de68d Binary files /dev/null and b/_images/takeoff.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..7f519b4f4 --- /dev/null +++ b/_modules/aviary/interface/cmd_entry_points.html @@ -0,0 +1,623 @@ + + + + + + + + + + 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.utils.engine_deck_conversion import _exec_EDC, _setup_EDC_parser, EDC_description
+from aviary.utils.aero_table_conversion import _exec_ATC, _setup_ATC_parser
+from aviary.visualization.dashboard import _dashboard_setup_parser, _dashboard_cmd
+from aviary.interface.graphical_input import _exec_flight_profile, _setup_flight_profile_parser
+from aviary.interface.download_models import _exec_hangar, _setup_hangar_parser
+
+
+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"),
+    'hangar': (_setup_hangar_parser, _exec_hangar,
+               "Allows users that pip installed Aviary to download models from the Aviary hangar"),
+    'convert_engine': (_setup_EDC_parser, _exec_EDC, EDC_description),
+    'convert_aero_table': (_setup_ATC_parser, _exec_ATC,
+                           'Converts FLOPS- or GASP-formatted aero data files into Aviary csv format.'),
+}
+
+
+

+[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/download_models.html b/_modules/aviary/interface/download_models.html new file mode 100644 index 000000000..e659d87e3 --- /dev/null +++ b/_modules/aviary/interface/download_models.html @@ -0,0 +1,601 @@ + + + + + + + + + + aviary.interface.download_models + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+
+ + +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+ +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

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

Source code for aviary.interface.download_models

+import os
+from pathlib import Path
+import argparse
+import pkg_resources
+import shutil
+
+
+

+[docs]
+def aviary_resource(resource_name: str) -> str:
+    return pkg_resources.resource_filename("aviary", resource_name)

+
+
+
+

+[docs]
+def get_model(file_name: str, verbose=False) -> Path:
+    '''
+    This function attempts to find the path to a file or folder in aviary/models
+    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.
+
+    Returns
+    -------
+    aviary_path
+        The absolute path to the file.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the path is not found.
+    '''
+
+    # Get the path to Aviary's models
+    path = Path('models', file_name)
+    aviary_path = Path(aviary_resource(str(path)))
+
+    # If the file name was provided without a path, check in the subfolders
+    if not aviary_path.exists():
+        sub_dirs = [x[0] for x in os.walk(aviary_resource('models'))]
+        for sub_dir in sub_dirs:
+            temp_path = Path(sub_dir, file_name)
+            if temp_path.exists():
+                # only return the first matching file
+                aviary_path = temp_path
+                continue
+
+    # If the path still doesn't exist, raise an error.
+    if not aviary_path.exists():
+        raise FileNotFoundError(
+            f"File or Folder not found in Aviary's hangar"
+        )
+    if verbose:
+        print('found', aviary_path, '\n')
+    return aviary_path

+
+
+
+

+[docs]
+def save_file(aviary_path: Path, outdir: Path, verbose=False) -> Path:
+    '''
+    Saves the file or folder specified into the output directory, creating directories as needed.
+    '''
+    outdir.mkdir(parents=True, exist_ok=True)
+    if aviary_path.is_dir():
+        if verbose:
+            print(aviary_path, 'is a directory, getting all files')
+        outdir = outdir.joinpath(aviary_path.stem)
+        outdir.mkdir(exist_ok=True)
+        for file in next(os.walk(aviary_path))[-1]:
+            if verbose:
+                print('copying', str(aviary_path / file), 'to', str(outdir / file))
+            shutil.copy2(aviary_path / file, outdir)
+    else:
+        if verbose:
+            print('copying', str(aviary_path), 'to', str(outdir / aviary_path.name))
+        shutil.copy2(aviary_path, outdir)
+    return outdir

+
+
+
+def _setup_hangar_parser(parser: argparse.ArgumentParser):
+    def_outdir = os.path.join(os.getcwd(), "aviary_models")
+    parser.add_argument(
+        'input_decks', metavar='indecks', type=str, nargs='+', help='Name of file or folder to download from Aviary/models'
+    )
+    parser.add_argument(
+        "-o", "--outdir", default=def_outdir, help="Directory to write outputs. Defaults to aviary_models in the current directory."
+    )
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose outputs",
+    )
+
+
+def _exec_hangar(args, user_args):
+    # check if args.input_deck is a list, if so, use the first element
+    input_decks = []
+    for input_deck in args.input_decks:
+        input_decks.append(get_model(input_deck, args.verbose))
+
+    for input_deck in input_decks:
+        save_file(input_deck, Path(args.outdir), args.verbose)
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..333132791 --- /dev/null +++ b/_modules/aviary/interface/graphical_input.html @@ -0,0 +1,1152 @@ + + + + + + + + + + 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_distance': 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': {
+                'time': ([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_distance': user_choices.get('solve_for_distance', 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_distance_var = tk.BooleanVar()
+        tk.Checkbutton(checkbox_frame, text="Solve for Range",
+                       variable=self.solve_for_distance_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_distance": self.solve_for_distance_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()

+

+
+
+
+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()
+
+
+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..ab95afbcc --- /dev/null +++ b/_modules/aviary/interface/methods_for_level1.html @@ -0,0 +1,694 @@ + + + + + + + + + + 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
+from pathlib import Path
+
+import openmdao.api as om
+from aviary.variable_info.enums import AnalysisScheme, Verbosity
+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, verbosity=Verbosity.BRIEF):
+    """
+    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, name=Path(aircraft_filename).stem)
+
+    # Load aircraft and options data from user
+    # Allow for user overrides here
+    prob.load_inputs(aircraft_filename, phase_info, verbosity=verbosity)
+
+    # 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, verbosity=verbosity)
+
+    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..f1b8f5a6f --- /dev/null +++ b/_modules/aviary/interface/methods_for_level2.html @@ -0,0 +1,3119 @@ + + + + + + + + + + aviary.interface.methods_for_level2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+
+ + +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+ +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

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

Source code for aviary.interface.methods_for_level2

+import csv
+import warnings
+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.core.component import Component
+from openmdao.utils.mpi import MPI
+from openmdao.utils.reports_system import _default_reports
+
+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.energy_phase import EnergyPhase
+from aviary.mission.twodof_phase import TwoDOFPhase
+from aviary.mission.gasp_based.ode.params import ParamPort
+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.groundroll_phase import GroundrollPhase
+from aviary.mission.flops_based.phases.groundroll_phase import GroundrollPhase as GroundrollPhaseVelocityIntegrated
+from aviary.mission.gasp_based.phases.rotation_phase import RotationPhase
+from aviary.mission.gasp_based.phases.climb_phase import ClimbPhase
+from aviary.mission.gasp_based.phases.cruise_phase import CruisePhase
+from aviary.mission.gasp_based.phases.accel_phase import AccelPhase
+from aviary.mission.gasp_based.phases.ascent_phase import AscentPhase
+from aviary.mission.gasp_based.phases.descent_phase import DescentPhase
+from aviary.mission.gasp_based.phases.landing_group import LandingSegment
+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.utils.functions import create_opts2vals, add_opts2vals, promote_aircraft_and_mission_vars, wrapped_convert_units
+from aviary.utils.process_input_decks import create_vehicle, update_GASP_options, initial_guessing
+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, Verbosity
+from aviary.variable_info.variable_meta_data import _MetaData as BaseMetaData
+
+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.phase_builder_base import PhaseBuilderBase
+
+
+FLOPS = LegacyCode.FLOPS
+GASP = LegacyCode.GASP
+
+TWO_DEGREES_OF_FREEDOM = EquationsOfMotion.TWO_DEGREES_OF_FREEDOM
+HEIGHT_ENERGY = EquationsOfMotion.HEIGHT_ENERGY
+SOLVED_2DOF = EquationsOfMotion.SOLVED_2DOF
+
+
+

+[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 AviaryGroup(om.Group):
+    """
+    A standard OpenMDAO group that handles Aviary's promotions in the configure
+    method. This assures that we only call set_input_defaults on variables
+    that are present in the model.
+    """
+
+

+[docs]
+    def initialize(self):
+        self.options.declare(
+            'aviary_options', types=AviaryValues,
+            desc='collection of Aircraft/Mission specific options')
+        self.options.declare(
+            'aviary_metadata', types=dict,
+            desc='metadata dictionary of the full aviary problem.')
+        self.options.declare(
+            'phase_info', types=dict,
+            desc='phase-specific settings.')

+
+
+

+[docs]
+    def configure(self):
+        aviary_options = self.options['aviary_options']
+        aviary_metadata = self.options['aviary_metadata']
+
+        # Find promoted name of every input in the model.
+        all_prom_inputs = []
+
+        # We can call list_inputs on the groups.
+        for system in self.system_iter(recurse=False, typ=om.Group):
+            var_abs = system.list_inputs(out_stream=None, val=False)
+            var_prom = [v['prom_name'] for k, v in var_abs]
+            all_prom_inputs.extend(var_prom)
+
+        # Component promotes aren't handled until this group resolves.
+        # Here, we address anything promoted with an alias in AviaryProblem.
+        for system in self.system_iter(recurse=False, typ=Component):
+            input_meta = system._var_promotes['input']
+            var_prom = [v[0][1] for v in input_meta if isinstance(v[0], tuple)]
+            all_prom_inputs.extend(var_prom)
+            var_prom = [v[0] for v in input_meta if not isinstance(v[0], tuple)]
+            all_prom_inputs.extend(var_prom)
+
+        if MPI and self.comm.size > 1:
+            # Under MPI, promotion info only lives on rank 0, so broadcast.
+            all_prom_inputs = self.comm.bcast(all_prom_inputs, root=0)
+
+        for key in aviary_metadata:
+
+            if ':' not in key or key.startswith('dynamic:'):
+                continue
+
+            if aviary_metadata[key]['option']:
+                continue
+
+            # Skip anything that is not presently an input.
+            if key not in all_prom_inputs:
+                continue
+
+            if key in aviary_options:
+                val, units = aviary_options.get_item(key)
+            else:
+                val = aviary_metadata[key]['default_value']
+                units = aviary_metadata[key]['units']
+
+                if val is None:
+                    # optional, but no default value
+                    continue
+
+            self.set_input_defaults(key, val=val, units=units)
+
+        # The section below this contains some manipulations of the dymos solver
+        # structure for height energy.
+        if aviary_options.get_val(Settings.EQUATIONS_OF_MOTION) is not HEIGHT_ENERGY:
+            return
+
+        phase_info = self.options['phase_info']
+
+        # Set a more appropriate solver for dymos when the phases are linked.
+        if MPI and isinstance(self.traj.phases.linear_solver, om.PETScKrylov):
+
+            # When any phase is connected with input_initial = True, dymos puts
+            # a jacobi solver in the phases group. This is necessary in case
+            # the phases are cyclic. However, this causes some problems
+            # with the newton solvers in Aviary, exacerbating issues with
+            # solver tolerances at multiple levels. Since Aviary's phases
+            # are basically in series, the jacobi solver is a much better
+            # choice and should be able to handle it in a couple of
+            # iterations.
+            self.traj.phases.linear_solver = om.LinearBlockJac(maxiter=5)
+
+        # Due to recent changes in dymos, there is now a solver in any phase
+        # that has connected initial states. It is not clear that this solver
+        # is necessary except in certain corner cases that do not apply to the
+        # Aviary trajectory. In our case, this solver merely addresses a lag
+        # in the state input component. Since this solver can cause some
+        # numerical problems, and can slow things down, we need to move it down
+        # into the state interp component.
+        # TODO: Future updates to dymos may make this unneccesary.
+        for phase in self.traj.phases.system_iter(recurse=False):
+
+            # Don't move the solvers if we are using solve segements.
+            if phase_info[phase.name]['user_options'].get('solve_for_distance'):
+                continue
+
+            phase.nonlinear_solver = om.NonlinearRunOnce()
+            phase.linear_solver = om.LinearRunOnce()
+            if isinstance(phase.indep_states, om.ImplicitComponent):
+                phase.indep_states.nonlinear_solver = \
+                    om.NewtonSolver(solve_subsystems=True)
+                phase.indep_states.linear_solver = om.DirectSolver()

+

+
+
+
+

+[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):
+        # Modify OpenMDAO's default_reports for this session.
+        new_reports = ['subsystems', 'mission', 'timeseries_csv']
+        for report in new_reports:
+            if report not in _default_reports:
+                _default_reports.append(report)
+
+        super().__init__(**kwargs)
+
+        self.timestamp = datetime.now()
+
+        self.model = AviaryGroup()
+        self.pre_mission = PreMissionGroup()
+        self.post_mission = PostMissionGroup()
+
+        self.aviary_inputs = None
+
+        self.traj = None
+
+        self.analysis_scheme = analysis_scheme
+
+        self.regular_phases = []
+        self.reserve_phases = []

+
+
+

+[docs]
+    def load_inputs(self, aviary_inputs, phase_info=None, engine_builder=None, verbosity=Verbosity.BRIEF):
+        """
+        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
+
+        # Create AviaryValues object from file (or process existing AviaryValues object
+        # with default values from metadata) and generate initial guesses
+        aviary_inputs, initial_guesses = create_vehicle(
+            aviary_inputs, verbosity=verbosity)
+
+        # pull which methods will be used for subsystems and mission
+        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 or mass_method is GASP:
+            aviary_inputs = update_GASP_options(aviary_inputs)
+            initial_guesses = initial_guessing(aviary_inputs, initial_guesses)
+        self.aviary_inputs = aviary_inputs
+        self.initial_guesses = initial_guesses
+
+        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
+
+            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
+
+                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': []}
+
+        ## PROCESSING ##
+        # set up core subsystems
+        if mission_method in (HEIGHT_ENERGY, SOLVED_2DOF):
+            everything_else_origin = FLOPS
+        elif mission_method is TWO_DEGREES_OF_FREEDOM:
+            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 phase_separator(self):
+        """
+        This method checks for reserve=True & False
+        Returns an error if a non-reserve phase is specified after a reserve phase.
+        return two dictionaries of phases: regular_phases and reserve_phases
+        """
+
+        # Check to ensure no non-reserve phases are specified after reserve phases
+        start_reserve = False
+        raise_error = False
+        for idx, phase_name in enumerate(self.phase_info):
+            if 'user_options' in self.phase_info[phase_name]:
+                if 'reserve' in self.phase_info[phase_name]["user_options"]:
+                    if self.phase_info[phase_name]["user_options"]["reserve"] is False:
+                        # This is a regular phase
+                        self.regular_phases.append(phase_name)
+                        if start_reserve is True:
+                            raise_error = True
+                    else:
+                        # This is a reserve phase
+                        self.reserve_phases.append(phase_name)
+                        start_reserve = True
+                else:
+                    # This is a regular phase by default
+                    self.regular_phases.append(phase_name)
+                    if start_reserve is True:
+                        raise_error = True
+
+        if raise_error is True:
+            raise ValueError(
+                f'In phase_info, reserve=False cannot be specified after a phase where reserve=True. '
+                f'All reserve phases must happen after non-reserve phases. '
+                f'Regular Phases : {self.regular_phases} | '
+                f'Reserve Phases : {self.reserve_phases} ')

+
+
+

+[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.
+        """
+
+        # Target_distance verification for all phases
+        # Checks to make sure target_distance is positive,
+        for idx, phase_name in enumerate(self.phase_info):
+            if 'user_options' in self.phase_info[phase_name]:
+                if 'target_distance' in self.phase_info[phase_name]["user_options"]:
+                    target_distance = self.phase_info[phase_name]["user_options"]["target_distance"]
+                    if target_distance[0] <= 0:
+                        raise ValueError(
+                            f"Invalid target_distance in [{phase_name}].[user_options]. "
+                            f"Current (value: {target_distance[0]}), (units: {target_distance[1]}) <= 0")
+
+        # Checks to make sure target_duration is positive,
+        # Sets duration_bounds, initial_guesses, and fixed_duration
+        for idx, phase_name in enumerate(self.phase_info):
+            if 'user_options' in self.phase_info[phase_name]:
+                analytic = False
+                if (self.analysis_scheme is AnalysisScheme.COLLOCATION) and (self.mission_method is EquationsOfMotion.TWO_DEGREES_OF_FREEDOM):
+                    try:
+                        # if the user provided an option, use it
+                        analytic = self.phase_info[phase_name]["user_options"]['analytic']
+                    except KeyError:
+                        # if it isn't specified, only the default 2DOF cruise for collocation is analytic
+                        if 'cruise' in phase_name:
+                            analytic = self.phase_info[phase_name]["user_options"]['analytic'] = True
+                        else:
+                            analytic = self.phase_info[phase_name]["user_options"]['analytic'] = False
+
+                if 'target_duration' in self.phase_info[phase_name]["user_options"]:
+                    target_duration = self.phase_info[phase_name]["user_options"]["target_duration"]
+                    if target_duration[0] <= 0:
+                        raise ValueError(
+                            f"Invalid target_duration in phase_info[{phase_name}][user_options]. "
+                            f"Current (value: {target_duration[0]}), (units: {target_duration[1]}) <= 0")
+
+                    # Only applies to non-analytic phases (all HE and most 2DOF)
+                    if not analytic:
+                        # Set duration_bounds and initial_guesses for time:
+                        self.phase_info[phase_name]["user_options"].update({
+                            "duration_bounds": ((target_duration[0], target_duration[0]), target_duration[1])})
+                        self.phase_info[phase_name].update({
+                            "initial_guesses": {"time": ((target_duration[0], target_duration[0]), target_duration[1])}})
+                        # Set Fixed_duration to true:
+                        self.phase_info[phase_name]["user_options"].update({
+                            "fix_duration": True})
+
+        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)
+
+        if self.mission_method in (HEIGHT_ENERGY, SOLVED_2DOF, TWO_DEGREES_OF_FREEDOM):
+            self.phase_separator()

+
+
+

+[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_two_dof_takeoff_systems()
+
+        # Check for HE mission method
+        elif self.mission_method is HEIGHT_ENERGY:
+            self._add_height_energy_takeoff_systems()

+
+
+    def _add_height_energy_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_two_dof_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)
+
+        if self.analysis_scheme is AnalysisScheme.SHOOTING:
+            self._add_fuel_reserve_component(post_mission=False)
+
+        # 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"],
+                    t_init_gear={"units": "s"},
+                    t_init_flaps={"units": "s"},
+                    tau_gear={"units": "unitless"},
+                    tau_flaps={"units": "unitless"},
+                    m={"units": "s"},
+                    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 _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(
+                "velocity",
+                eq_units="ft/s",
+                normalize=True,
+                add_constraint=True,
+            ),
+        )
+        self.model.connect(Mission.Takeoff.ROTATION_VELOCITY,
+                           "groundroll_boundary.rhs:velocity")
+        self.model.connect(
+            "traj.groundroll.states:velocity",
+            "groundroll_boundary.lhs:velocity",
+            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_phase(self, phase_name, phase_idx):
+        base_phase_options = self.phase_info[phase_name]
+
+        # 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():
+            phase_options[key] = val
+
+        phase_options['user_options'] = {}
+        for key, val in base_phase_options['user_options'].items():
+            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 TWO_DEGREES_OF_FREEDOM:
+            if 'groundroll' in phase_name:
+                phase_builder = GroundrollPhase
+            elif 'rotation' in phase_name:
+                phase_builder = RotationPhase
+            elif 'accel' in phase_name:
+                phase_builder = AccelPhase
+            elif 'ascent' in phase_name:
+                phase_builder = AscentPhase
+            elif 'climb' in phase_name:
+                phase_builder = ClimbPhase
+            elif 'cruise' in phase_name:
+                phase_builder = CruisePhase
+            elif 'desc' in phase_name:
+                phase_builder = DescentPhase
+            else:
+                raise ValueError(
+                    f'{phase_name} does not have an associated phase_builder \n phase_name must '
+                    'include one of: groundroll, rotation, accel, ascent, climb, cruise, or desc')
+
+        if self.mission_method is HEIGHT_ENERGY:
+            if 'phase_builder' in phase_options:
+                phase_builder = phase_options['phase_builder']
+                if not issubclass(phase_builder, PhaseBuilderBase):
+                    raise TypeError(
+                        f"phase_builder for the phase called {phase_name} must be a PhaseBuilderBase object.")
+            else:
+                phase_builder = EnergyPhase
+
+        if self.mission_method is SOLVED_2DOF:
+            if phase_options['user_options']['ground_roll'] and phase_options['user_options']['fix_initial']:
+                phase_builder = GroundrollPhaseVelocityIntegrated
+            else:
+                phase_builder = TwoDOFPhase
+
+        phase_object = phase_builder.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)
+
+        self.phase_objects.append(phase_object)
+
+        # 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', ()))
+
+        try:
+            fix_initial = user_options.get_val('fix_initial')
+        except KeyError:
+            fix_intial = False
+
+        try:
+            fix_duration = user_options.get_val('fix_duration')
+        except KeyError:
+            fix_duration = False
+
+        if 'ascent' in phase_name and self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            phase.set_time_options(
+                units="s",
+                targets="t_curr",
+                input_initial=True,
+                input_duration=True,
+            )
+        elif 'cruise' in phase_name and self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            # 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=(0., 1.e7),
+                initial_ref=100.e3,
+                duration_bounds=(-1.e7, -1),
+                duration_ref=50000,
+            )
+        elif 'descent' in phase_name and self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            duration_ref = user_options.get_val("duration_ref", 's')
+            phase.set_time_options(
+                duration_bounds=duration_bounds,
+                fix_initial=fix_initial,
+                input_initial=input_initial,
+                units="s",
+                duration_ref=duration_ref,
+            )
+        else:
+            # The rest of the phases includes all Height Energy method phases
+            # and any 2DOF phases that don't fall into the naming patterns
+            # above.
+            input_initial = False
+            time_units = phase.time_options['units']
+
+            # Make a good guess for a reasonable intitial time scaler.
+            try:
+                initial_bounds = user_options.get_val('initial_bounds', units=time_units)
+            except KeyError:
+                initial_bounds = (None, None)
+
+            if initial_bounds[0] is not None and initial_bounds[1] != 0.0:
+                # Upper bound is good for a ref.
+                user_options.set_val('initial_ref', initial_bounds[1],
+                                     units=time_units)
+            else:
+                user_options.set_val('initial_ref', 600., time_units)
+
+            duration_bounds = user_options.get_val("duration_bounds", time_units)
+            user_options.set_val(
+                'duration_ref', (duration_bounds[0] + duration_bounds[1]) / 2.,
+                time_units
+            )
+            if phase_idx > 0:
+                input_initial = True
+
+            if fix_initial or input_initial:
+                phase.set_time_options(
+                    fix_initial=fix_initial, fix_duration=fix_duration, units=time_units,
+                    duration_bounds=user_options.get_val("duration_bounds", time_units),
+                    duration_ref=user_options.get_val("duration_ref", time_units),
+                    initial_ref=user_options.get_val("initial_ref", time_units),
+                )
+            elif phase_name == 'descent' and self.mission_method is HEIGHT_ENERGY:  # TODO: generalize this logic for all phases
+                phase.set_time_options(
+                    fix_initial=False, fix_duration=False, units=time_units,
+                    duration_bounds=user_options.get_val("duration_bounds", time_units),
+                    duration_ref=user_options.get_val("duration_ref", time_units),
+                    initial_bounds=initial_bounds,
+                    initial_ref=user_options.get_val("initial_ref", time_units),
+                )
+            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=time_units,
+                    duration_bounds=user_options.get_val("duration_bounds", time_units),
+                    duration_ref=user_options.get_val("duration_ref", time_units),
+                    initial_bounds=initial_bounds,
+                    initial_ref=user_options.get_val("initial_ref", time_units),
+                )
+
+        if 'cruise' not in phase_name and self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            phase.add_control(
+                Dynamic.Mission.THROTTLE, targets=Dynamic.Mission.THROTTLE, units='unitless',
+                opt=False,
+            )
+
+        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, self.post_mission_info = phase_info_parameterization(self.phase_info,
+                                                                                  self.post_mission_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_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
+
+            # based on reserve_fuel
+            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(
+                    verbosity=Verbosity.DEBUG,
+                ),
+            )
+            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'], Dynamic.Mission.VELOCITY, 0,),
+                    (phases['climb3']['ode'], Dynamic.Mission.ALTITUDE, 0,),
+                    (phases['cruise']['ode'], Dynamic.Mission.MASS, 0,),
+                ],
+                traj_intermediate_state_output=[
+                    ('cruise', Dynamic.Mission.DISTANCE),
+                    ('cruise', Dynamic.Mission.MASS),
+                ]
+            )
+            traj = self.model.add_subsystem('traj', full_traj)
+
+            self.model.add_subsystem(
+                'actual_descent_fuel',
+                om.ExecComp('actual_descent_fuel = traj_cruise_mass_final - traj_mass_final',
+                            actual_descent_fuel={'units': 'lbm'},
+                            traj_cruise_mass_final={'units': 'lbm'},
+                            traj_mass_final={'units': 'lbm'},
+                            ))
+
+            self.model.connect(
+                'traj.mass_final',
+                'actual_descent_fuel.traj_mass_final',
+                src_indices=[-1],
+                flat_src_indices=True,
+            )
+            self.model.connect(
+                'traj.cruise_mass_final',
+                'actual_descent_fuel.traj_cruise_mass_final',
+                src_indices=[-1],
+                flat_src_indices=True,
+            )
+            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 in (TWO_DEGREES_OF_FREEDOM, HEIGHT_ENERGY, SOLVED_2DOF):
+            if self.analysis_scheme is AnalysisScheme.COLLOCATION:
+                self.phase_objects = []
+                for phase_idx, phase_name in enumerate(phases):
+                    phase = traj.add_phase(
+                        phase_name, self._get_phase(phase_name, phase_idx))
+                    add_subsystem_timeseries_outputs(phase, phase_name)
+
+                    if phase_name == 'ascent' and self.mission_method is TWO_DEGREES_OF_FREEDOM:
+                        self._add_groundroll_eq_constraint(phase)
+
+            # 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]
+
+            if self.mission_method in (HEIGHT_ENERGY, SOLVED_2DOF):
+                traj = setup_trajectory_params(
+                    self.model, traj, self.aviary_inputs, phases, meta_data=self.meta_data, external_parameters=external_parameters)
+
+        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 self.pre_mission_info['include_takeoff'] and self.mission_method is HEIGHT_ENERGY:
+            self._add_post_mission_takeoff_systems()
+
+        if include_landing and self.post_mission_info['include_landing']:
+            if self.mission_method is HEIGHT_ENERGY:
+                self._add_height_energy_landing_systems()
+            elif self.mission_method is TWO_DEGREES_OF_FREEDOM:
+                self._add_two_dof_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 in (HEIGHT_ENERGY, SOLVED_2DOF, TWO_DEGREES_OF_FREEDOM):
+            # Check if regular_phases[] is accessible
+            try:
+                self.regular_phases[0]
+            except:
+                raise ValueError(
+                    f"regular_phases[] dictionary is not accessible."
+                    f" For HEIGHT_ENERGY and SOLVED_2DOF missions, check_and_preprocess_inputs()"
+                    f" must be called before add_post_mission_systems().")
+
+            # Fuel burn in regular phases
+            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_burned', ecomp,
+                                            promotes=[('fuel_burned', Mission.Summary.FUEL_BURNED)])
+
+            if self.analysis_scheme is AnalysisScheme.SHOOTING:
+                # shooting method currently doesn't have timeseries
+                self.post_mission.promotes('fuel_burned', [
+                    ('initial_mass', Mission.Summary.GROSS_MASS),
+                    ('mass_final', Mission.Landing.TOUCHDOWN_MASS),
+                ])
+            else:
+                # timeseries has to be used because Breguet cruise phases don't have states
+                self.model.connect(f"traj.{self.regular_phases[0]}.timeseries.mass",
+                                   "fuel_burned.initial_mass", src_indices=[0])
+                self.model.connect(f"traj.{self.regular_phases[-1]}.timeseries.mass",
+                                   "fuel_burned.mass_final", src_indices=[-1])
+
+            # Fuel burn in reserve phases
+            if self.reserve_phases:
+                ecomp = om.ExecComp('reserve_fuel_burned = initial_mass - mass_final',
+                                    initial_mass={'units': 'lbm'},
+                                    mass_final={'units': 'lbm'},
+                                    reserve_fuel_burned={'units': 'lbm'})
+
+                self.post_mission.add_subsystem('reserve_fuel_burned', ecomp,
+                                                promotes=[('reserve_fuel_burned', Mission.Summary.RESERVE_FUEL_BURNED)])
+
+                if self.analysis_scheme is AnalysisScheme.SHOOTING:
+                    # shooting method currently doesn't have timeseries
+                    self.post_mission.promotes('reserve_fuel_burned', [
+                        ('initial_mass', Mission.Landing.TOUCHDOWN_MASS),
+                    ])
+                    self.model.connect(f"traj.{self.reserve_phases[-1]}.states:mass",
+                                       "reserve_fuel_burned.mass_final", src_indices=[-1])
+                else:
+                    # timeseries has to be used because Breguet cruise phases don't have states
+                    self.model.connect(f"traj.{self.reserve_phases[0]}.timeseries.mass",
+                                       "reserve_fuel_burned.initial_mass", src_indices=[0])
+                    self.model.connect(f"traj.{self.reserve_phases[-1]}.timeseries.mass",
+                                       "reserve_fuel_burned.mass_final", src_indices=[-1])
+
+            if self.analysis_scheme is not AnalysisScheme.SHOOTING:
+                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 = (1 + fuel_margin/100)*fuel_burned + reserve_fuel',
+                                overall_fuel={'units': 'lbm', 'shape': 1},
+                                fuel_margin={"units": "unitless", 'val': 0},
+                                fuel_burned={'units': 'lbm'},  # from regular_phases only
+                                reserve_fuel={'units': 'lbm', 'shape': 1},
+                                )
+            self.post_mission.add_subsystem(
+                'fuel_calc', ecomp,
+                promotes_inputs=[
+                    ("fuel_margin", Aircraft.Fuel.FUEL_MARGIN),
+                    ('fuel_burned', Mission.Summary.FUEL_BURNED),
+                    ("reserve_fuel", Mission.Design.RESERVE_FUEL),
+                ],
+                promotes_outputs=[('overall_fuel', Mission.Summary.TOTAL_FUEL_MASS)])
+
+            # If a target range has been specified
+            # range is measured from the start of the first phase to the end of the last normal phase
+            if 'target_range' in self.post_mission_info:
+                target_range = wrapped_convert_units(
+                    self.post_mission_info['target_range'], 'nmi')
+                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, 'units': 'nmi'},
+                    ),
+                    promotes_inputs=[
+                        "target_range",
+                    ],
+                    promotes_outputs=[
+                        ("range_resid", Mission.Constraints.RANGE_RESIDUAL)],
+                )
+
+                # determine distance traveled based on regular_phases
+                self.model.connect(
+                    f"traj.{self.regular_phases[-1]}.timeseries.distance", "range_constraint.actual_range", src_indices=[-1])
+                self.model.add_constraint(
+                    Mission.Constraints.RANGE_RESIDUAL, equals=0.0, ref=1.e2)
+
+            # If a target distance (or time) has been specified for this phase
+            # distance (or time) is measured from the start of this phase to the end of this phase
+            for idx, phase_name in enumerate(self.phase_info):
+                if 'target_distance' in self.phase_info[phase_name]["user_options"]:
+                    target_distance = wrapped_convert_units(
+                        self.phase_info[phase_name]["user_options"]["target_distance"], 'nmi')
+                    self.post_mission.add_subsystem(
+                        f"{phase_name}_distance_constraint",
+                        om.ExecComp(
+                            "distance_resid = target_distance - (final_distance - initial_distance)",
+                            distance_resid={'units': 'nmi'},
+                            target_distance={'val': target_distance, 'units': 'nmi'},
+                            final_distance={'units': 'nmi'},
+                            initial_distance={'units': 'nmi'},
+                        ))
+                    self.model.connect(
+                        f"traj.{phase_name}.timeseries.distance",
+                        f"{phase_name}_distance_constraint.final_distance", src_indices=[-1])
+                    self.model.connect(
+                        f"traj.{phase_name}.timeseries.distance",
+                        f"{phase_name}_distance_constraint.initial_distance", src_indices=[0])
+                    self.model.add_constraint(
+                        f"{phase_name}_distance_constraint.distance_resid", equals=0.0, ref=1e2)
+
+                # this is only used for analytic phases with a target duration
+                if 'target_duration' in self.phase_info[phase_name]["user_options"] and \
+                        self.phase_info[phase_name]["user_options"].get("analytic", False):
+                    target_duration = wrapped_convert_units(
+                        self.phase_info[phase_name]["user_options"]["target_duration"], 'min')
+                    self.post_mission.add_subsystem(
+                        f"{phase_name}_duration_constraint",
+                        om.ExecComp(
+                            "duration_resid = target_duration - (final_time - initial_time)",
+                            duration_resid={'units': 'min'},
+                            target_duration={'val': target_duration, 'units': 'min'},
+                            final_time={'units': 'min'},
+                            initial_time={'units': 'min'},
+                        ))
+                    self.model.connect(
+                        f"traj.{phase_name}.timeseries.time",
+                        f"{phase_name}_duration_constraint.final_time", src_indices=[-1])
+                    self.model.connect(
+                        f"traj.{phase_name}.timeseries.time",
+                        f"{phase_name}_duration_constraint.initial_time", src_indices=[0])
+                    self.model.add_constraint(
+                        f"{phase_name}_duration_constraint.duration_resid", equals=0.0, ref=1e2)
+
+        if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            self._add_two_dof_objectives()
+
+        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 in (HEIGHT_ENERGY, TWO_DEGREES_OF_FREEDOM):
+            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):
+        # Initialize a list to keep track of indices where option_name is True
+        true_option_indices = []
+
+        # Loop through phases to find where option_name is True
+        for idx, phase_name in enumerate(phases):
+            if self.phase_info[phase_name]['user_options'].get(option_name, False):
+                true_option_indices.append(idx)
+
+        # Determine the groups of phases to link based on consecutive indices
+        groups_to_link = []
+        current_group = []
+
+        for idx in true_option_indices:
+            if not current_group or idx == current_group[-1] + 1:
+                # If the current index is consecutive, add it to the current group
+                current_group.append(idx)
+            else:
+                # Otherwise, start a new group and save the previous one
+                groups_to_link.append(current_group)
+                current_group = [idx]
+
+        # Add the last group if it exists
+        if current_group:
+            groups_to_link.append(current_group)
+
+        # Loop through each group and determine the phases to link
+        for group in groups_to_link:
+            # Extend the group to include the phase before the first True option and after the last True option, if applicable
+            if group[0] > 0:
+                group.insert(0, group[0] - 1)
+            if group[-1] < len(phases) - 1:
+                group.append(group[-1] + 1)
+
+            # Extract the phase names for the current group
+            phases_to_link = [phases[idx] for idx in group]
+
+            # Link the phases for the current group
+            if len(phases_to_link) > 1:
+                self.traj.link_phases(phases=phases_to_link, vars=[var], **kwargs)
+
+
+
+
+

+[docs]
+    def add_driver(self, optimizer=None, use_coloring=None, max_iter=50, verbosity=Verbosity.BRIEF):
+        """
+        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.
+
+        verbosity : Verbosity or list, optional
+            If Verbosity.DEBUG, 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":
+            if verbosity == Verbosity.QUIET:
+                isumm, iprint = 0, 0
+            elif verbosity == Verbosity.BRIEF:
+                isumm, iprint = 6, 0
+            else:
+                isumm, iprint = 6, 9
+            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"] = isumm
+            driver.opt_settings["iPrint"] = iprint
+        elif driver.options["optimizer"] == "IPOPT":
+            if verbosity == Verbosity.QUIET:
+                print_level = 3  # minimum to get exit status
+                driver.opt_settings['print_user_options'] = 'no'
+            elif verbosity == Verbosity.BRIEF:
+                print_level = 5
+                driver.opt_settings['print_user_options'] = 'no'
+                driver.opt_settings['print_frequency_iter'] = 10
+            elif verbosity == Verbosity.VERBOSE:
+                print_level = 5
+            else:
+                print_level = 7
+            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'] = print_level
+            # 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":
+            if verbosity == Verbosity.QUIET:
+                disp = False
+            else:
+                disp = True
+            driver.options["tol"] = 1e-9
+            driver.options["maxiter"] = max_iter
+            driver.options["disp"] = disp
+
+        if verbosity != Verbosity.QUIET:
+            if isinstance(verbosity, list):
+                driver.options['debug_print'] = verbosity
+            elif verbosity.value > Verbosity.DEBUG.value:
+                driver.options['debug_print'] = ['desvars', 'ln_cons', 'nl_cons', 'objs']
+        if verbosity is not Verbosity.DEBUG and optimizer in ("SNOPT", "IPOPT"):
+            driver.options['print_results'] = False

+
+
+

+[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 in (HEIGHT_ENERGY, SOLVED_2DOF):
+            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.e2, 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="unitless", ref=1)
+                self.model.add_design_var("tau_flaps", lower=0.01,
+                                          upper=1.0, units="unitless", 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)
+
+            # 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)
+
+            final_phase_name = self.regular_phases[-1]
+            if objective_type == 'mass':
+                if self.analysis_scheme is AnalysisScheme.COLLOCATION:
+                    self.model.add_objective(
+                        f"traj.{final_phase_name}.timeseries.{Dynamic.Mission.MASS}", index=-1, ref=ref)
+                else:
+                    last_phase = self.traj._phases.items()[final_phase_name]
+                    last_phase.add_objective(
+                        Dynamic.Mission.MASS, loc='final', ref=ref)
+            elif objective_type == 'time':
+                self.model.add_objective(
+                    f"traj.{final_phase_name}.timeseries.time", index=-1, 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(Mission.Summary.FUEL_BURNED, ref=ref)
+            elif objective_type == "fuel":
+                self.model.add_objective(Mission.Objectives.FUEL, ref=ref)
+
+        # set objective ref on height-energy missions
+        elif self.mission_method is HEIGHT_ENERGY:
+            ref = ref if ref is not None else default_ref_values.get(
+                'fuel_burned', 1)
+            self.model.add_objective(Mission.Summary.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.
+        """
+        # suppress warnings:
+        # "input variable '...' promoted using '*' was already promoted using 'aircraft:*'
+        with warnings.catch_warnings():
+
+            self.model.options['aviary_options'] = self.aviary_inputs
+            self.model.options['aviary_metadata'] = self.meta_data
+            self.model.options['phase_info'] = self.phase_info
+
+            warnings.simplefilter("ignore", om.OpenMDAOWarning)
+            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. 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_2DOF:
+                self.phase_objects[idx].apply_initial_guesses(self, 'traj', phase)
+                if self.phase_info[phase_name]['user_options']['ground_roll'] and self.phase_info[phase_name]['user_options']['fix_initial']:
+                    continue
+
+            # If not, fetch the initial guesses specific to the phase
+            # check if guesses exist for this phase
+            if "initial_guesses" in self.phase_info[phase_name]:
+                guesses = self.phase_info[phase_name]['initial_guesses']
+            else:
+                guesses = {}
+
+            if self.mission_method is TWO_DEGREES_OF_FREEDOM and \
+                    self.phase_info[phase_name]["user_options"].get("analytic", False):
+                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 in (HEIGHT_ENERGY, SOLVED_2DOF):
+            control_keys = ["mach", "altitude"]
+            state_keys = ["mass", Dynamic.Mission.DISTANCE]
+        else:
+            control_keys = ["velocity_rate", "throttle"]
+            state_keys = ["altitude", "mass",
+                          Dynamic.Mission.DISTANCE, Dynamic.Mission.VELOCITY, "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 in (HEIGHT_ENERGY, SOLVED_2DOF):
+            initial_altitude = wrapped_convert_units(
+                self.phase_info[phase_name]['user_options']['initial_altitude'], 'ft')
+            final_altitude = wrapped_convert_units(
+                self.phase_info[phase_name]['user_options']['final_altitude'], 'ft')
+            initial_mach = self.phase_info[phase_name]['user_options']['initial_mach']
+            final_mach = self.phase_info[phase_name]['user_options']['final_mach']
+
+            guesses["mach"] = ([initial_mach[0], final_mach[0]], "unitless")
+            guesses["altitude"] = ([initial_altitude, final_altitude], 'ft')
+
+        if self.mission_method is HEIGHT_ENERGY:
+            # if time not in initial guesses, set it to the average of the initial_bounds and the duration_bounds
+            if 'time' not in guesses:
+                initial_bounds = wrapped_convert_units(
+                    self.phase_info[phase_name]['user_options']['initial_bounds'], 's')
+                duration_bounds = wrapped_convert_units(
+                    self.phase_info[phase_name]['user_options']['duration_bounds'], 's')
+                guesses["time"] = ([np.mean(initial_bounds[0]), np.mean(
+                    duration_bounds[0])], 's')
+
+            # if time not in initial guesses, set it to the average of the initial_bounds and the duration_bounds
+            if 'time' not in guesses:
+                initial_bounds = self.phase_info[phase_name]['user_options']['initial_bounds']
+                duration_bounds = self.phase_info[phase_name]['user_options']['duration_bounds']
+                # Add a check for the initial and duration bounds, raise an error if they are not consistent
+                if initial_bounds[1] != duration_bounds[1]:
+                    raise ValueError(
+                        f"Initial and duration bounds for {phase_name} are not consistent.")
+                guesses["time"] = ([np.mean(initial_bounds[0]), np.mean(
+                    duration_bounds[0])], initial_bounds[1])
+
+        for guess_key, guess_data in guesses.items():
+            val, units = guess_data
+
+            # Set initial guess for time variables
+            if 'time' == guess_key and self.mission_method is not SOLVED_2DOF:
+                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)
+
+                if self.mission_method is SOLVED_2DOF:
+                    continue
+
+                if guess_key in control_keys:
+                    pass
+                # 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.")
+
+        if self.mission_method is SOLVED_2DOF:
+            return
+
+        # 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 self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            base_phase = phase_name.removeprefix('reserve_')
+        else:
+            base_phase = phase_name
+        if 'mass' not in guesses:
+            if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+                # Determine a mass guess depending on the phase name
+                if base_phase in ["groundroll", "rotation", "ascent", "accel", "climb1"]:
+                    mass_guess = rotation_mass
+                elif base_phase == "climb2":
+                    mass_guess = 0.99 * rotation_mass
+                elif "desc" in base_phase:
+                    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 'time' not in guesses:
+            # Determine initial time and duration guesses depending on the phase name
+            if 'desc1' == base_phase:
+                t_initial = flight_duration*.9
+                t_duration = flight_duration*.04
+            elif 'desc2' in base_phase:
+                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' == base_phase:
+                    ys = [self.target_range*.97, self.target_range*.99]
+                elif 'desc2' in base_phase:
+                    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(
+                        Dynamic.Mission.DISTANCE, ys=ys)
+                )
+
+

+[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('verbosity').value >= 2:
+            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('verbosity').value >= 2:
+            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.velocity',
+                           '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_height_energy_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:*'])
+
+        last_flight_phase_name = list(self.phase_info.keys())[-1]
+        if self.phase_info[last_flight_phase_name]['user_options'].get('use_polynomial_control', True):
+            control_type_string = 'polynomial_control_values'
+        else:
+            control_type_string = 'control_values'
+
+        last_regular_phase = self.regular_phases[-1]
+        self.model.connect(f'traj.{last_regular_phase}.states:mass',
+                           Mission.Landing.TOUCHDOWN_MASS, src_indices=[-1])
+        self.model.connect(f'traj.{last_regular_phase}.{control_type_string}:altitude',
+                           Mission.Landing.INITIAL_ALTITUDE,
+                           src_indices=[0])
+
+    def _add_post_mission_takeoff_systems(self):
+        first_flight_phase_name = list(self.phase_info.keys())[0]
+        connect_takeoff_to_climb = not self.phase_info[first_flight_phase_name]['user_options'].get(
+            'add_initial_mass_constraint', True)
+
+        if connect_takeoff_to_climb:
+            self.model.connect(Mission.Takeoff.FINAL_MASS,
+                               f'traj.{first_flight_phase_name}.initial_states:mass')
+            self.model.connect(Mission.Takeoff.GROUND_DISTANCE,
+                               f'traj.{first_flight_phase_name}.initial_states:distance')
+
+            if self.phase_info[first_flight_phase_name]['user_options'].get('use_polynomial_control', True):
+                control_type_string = 'polynomial_control_values'
+            else:
+                control_type_string = 'control_values'
+
+            if self.phase_info[first_flight_phase_name]['user_options'].get('optimize_mach', False):
+                # Create an ExecComp to compute the difference in mach
+                mach_diff_comp = om.ExecComp(
+                    'mach_resid_for_connecting_takeoff = final_mach - initial_mach')
+                self.model.add_subsystem('mach_diff_comp', mach_diff_comp)
+
+                # Connect the inputs to the mach difference component
+                self.model.connect(Mission.Takeoff.FINAL_MACH,
+                                   'mach_diff_comp.final_mach')
+                self.model.connect(f'traj.{first_flight_phase_name}.{control_type_string}:mach',
+                                   'mach_diff_comp.initial_mach', src_indices=[0])
+
+                # Add constraint for mach difference
+                self.model.add_constraint(
+                    'mach_diff_comp.mach_resid_for_connecting_takeoff', equals=0.0)
+
+            if self.phase_info[first_flight_phase_name]['user_options'].get('optimize_altitude', False):
+                # Similar steps for altitude difference
+                alt_diff_comp = om.ExecComp(
+                    'altitude_resid_for_connecting_takeoff = final_altitude - initial_altitude', units='ft')
+                self.model.add_subsystem('alt_diff_comp', alt_diff_comp)
+
+                self.model.connect(Mission.Takeoff.FINAL_ALTITUDE,
+                                   'alt_diff_comp.final_altitude')
+                self.model.connect(f'traj.{first_flight_phase_name}.{control_type_string}:altitude',
+                                   'alt_diff_comp.initial_altitude', src_indices=[0])
+
+                self.model.add_constraint(
+                    'alt_diff_comp.altitude_resid_for_connecting_takeoff', equals=0.0)
+
+    def _add_two_dof_landing_systems(self):
+        self.model.add_subsystem(
+            "landing",
+            LandingSegment(
+                **(self.ode_args)),
+            promotes_inputs=['aircraft:*', 'mission:*',
+                             (Dynamic.Mission.MASS, Mission.Landing.TOUCHDOWN_MASS)],
+            promotes_outputs=['mission:*'],
+        )
+
+    def _add_two_dof_objectives(self):
+        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, post_mission=True,
+                                    reserves_name=Mission.Design.RESERVE_FUEL):
+        if post_mission:
+            reserve_calc_location = self.post_mission
+        else:
+            reserve_calc_location = self.model
+
+        RESERVE_FUEL_FRACTION = self.aviary_inputs.get_val(
+            Aircraft.Design.RESERVE_FUEL_FRACTION, units='unitless')
+        if RESERVE_FUEL_FRACTION != 0:
+            reserve_fuel_frac = om.ExecComp('reserve_fuel_frac_mass = reserve_fuel_fraction * (takeoff_mass - final_mass)',
+                                            reserve_fuel_frac_mass={"units": "lbm"},
+                                            reserve_fuel_fraction={
+                                                "units": "unitless", "val": RESERVE_FUEL_FRACTION},
+                                            final_mass={"units": "lbm"},
+                                            takeoff_mass={"units": "lbm"})
+
+            reserve_calc_location.add_subsystem("reserve_fuel_frac", reserve_fuel_frac,
+                                                promotes_inputs=[("takeoff_mass", Mission.Summary.GROSS_MASS),
+                                                                 ("final_mass",
+                                                                  Mission.Landing.TOUCHDOWN_MASS),
+                                                                 ("reserve_fuel_fraction", Aircraft.Design.RESERVE_FUEL_FRACTION)],
+                                                promotes_outputs=["reserve_fuel_frac_mass"])
+
+        RESERVE_FUEL_ADDITIONAL = self.aviary_inputs.get_val(
+            Aircraft.Design.RESERVE_FUEL_ADDITIONAL, units='lbm')
+        reserve_fuel = om.ExecComp('reserve_fuel = reserve_fuel_frac_mass + reserve_fuel_additional + reserve_fuel_burned',
+                                   reserve_fuel={"units": "lbm", 'shape': 1},
+                                   reserve_fuel_frac_mass={"units": "lbm", "val": 0},
+                                   reserve_fuel_additional={
+                                       "units": "lbm", "val": RESERVE_FUEL_ADDITIONAL},
+                                   reserve_fuel_burned={"units": "lbm", "val": 0})
+
+        reserve_calc_location.add_subsystem("reserve_fuel", reserve_fuel,
+                                            promotes_inputs=["reserve_fuel_frac_mass",
+                                                             ("reserve_fuel_additional",
+                                                              Aircraft.Design.RESERVE_FUEL_ADDITIONAL),
+                                                             ("reserve_fuel_burned", Mission.Summary.RESERVE_FUEL_BURNED)],
+                                            promotes_outputs=[
+                                                ("reserve_fuel", reserves_name)]
+                                            )

+
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..ee24569e8 --- /dev/null +++ b/_modules/aviary/interface/reports.html @@ -0,0 +1,782 @@ + + + + + + + + + + aviary.interface.reports + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+
+ + +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+ +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

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

Source code for aviary.interface.reports

+from pathlib import Path
+import pandas as pd
+import numpy as np
+
+from openmdao.utils.mpi import MPI
+from openmdao.utils.reports_system import register_report
+
+from aviary.interface.utils.markdown_utils import write_markdown_variable_table
+from aviary.utils.named_values import NamedValues
+from aviary.utils.functions import wrapped_convert_units
+
+
+

+[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 add flag to skip registering reports?
+
+    # Note: Due to a possible bug in OpenMDAO, we need to assign Problem as the
+    # class_name instead of AviaryProblem.
+
+    # 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='AviaryProblem',
+                    method='run_driver',
+                    pre_or_post='post',
+                    # **kwargs
+                    )
+
+    register_report(name='mission',
+                    func=mission_report,
+                    desc='Generates report for mission results from Aviary problem',
+                    class_name='AviaryProblem',
+                    method='run_driver',
+                    pre_or_post='post')
+
+    register_report(name='timeseries_csv',
+                    func=timeseries_csv,
+                    desc='Generates an output .csv file for variables in the timeseries of the trajectory',
+                    class_name='AviaryProblem',
+                    method='run_driver',
+                    pre_or_post='post')

+
+
+
+

+[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 used to generate this report
+    """
+
+    # Note: Due to a possible bug in OpenMDAO, we need to assign Problem as the
+    # class_name instead of AviaryProblem. Make sure that we don't try to write
+    # aviary reports without aviary in the model.
+    from aviary.interface.methods_for_level2 import AviaryProblem
+    if not isinstance(prob, AviaryProblem):
+        return
+
+    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)

+
+
+
+

+[docs]
+def mission_report(prob, **kwargs):
+    """
+    Creates a basic mission summary report that is placed in the "reports" folder
+
+    Parameters
+    ----------
+    prob : AviaryProblem
+        The AviaryProblem used to generate this report
+    """
+    def _get_phase_value(traj, phase, var_name, units, indices=None):
+        try:
+            vals = prob.get_val(f"{traj}.{phase}.timeseries.{var_name}",
+                                units=units,
+                                indices=indices,
+                                get_remote=True)
+        except KeyError:
+            try:
+                vals = prob.get_val(f"{traj}.{phase}.{var_name}",
+                                    units=units,
+                                    indices=indices,
+                                    get_remote=True)
+            # 2DOF breguet range cruise uses time integration to track mass
+            except TypeError:
+                vals = prob.get_val(f"{traj}.{phase}.timeseries.time",
+                                    units=units,
+                                    indices=indices,
+                                    get_remote=True)
+            except KeyError:
+                vals = None
+
+        return vals
+
+    def _get_phase_diff(traj, phase, var_name, units, indices=[0, -1]):
+        vals = _get_phase_value(traj, phase, var_name, units, indices)
+
+        if vals is not None:
+            diff = vals[-1]-vals[0]
+            if isinstance(diff, np.ndarray):
+                diff = diff[0]
+            return diff
+        else:
+            return None
+
+    # Note: Due to a possible bug in OpenMDAO, we need to assign Problem as the
+    # class_name instead of AviaryProblem. Make sure that we don't try to write
+    # aviary reports without aviary in the model.
+    from aviary.interface.methods_for_level2 import AviaryProblem
+    if not isinstance(prob, AviaryProblem):
+        return
+
+    reports_folder = Path(prob.get_reports_dir())
+    report_file = reports_folder / 'mission_summary.md'
+
+    # read per-phase data from trajectory
+    data = {}
+    for idx, phase in enumerate(prob.phase_info):
+        # TODO for traj in trajectories, currently assuming single one named "traj"
+        # TODO delta mass and fuel consumption need to be tracked separately
+        fuel_burn = _get_phase_diff('traj', phase, 'mass', 'lbm', [-1, 0])
+        time = _get_phase_diff('traj', phase, 't', 'min')
+        range = _get_phase_diff('traj', phase, 'distance', 'nmi')
+
+        # get initial values, first in traj
+        if idx == 0:
+            initial_mass = _get_phase_value('traj', phase, 'mass', 'lbm', 0)[0]
+            initial_time = _get_phase_value('traj', phase, 't', 'min', 0)
+            initial_range = _get_phase_value('traj', phase, 'distance', 'nmi', 0)[0]
+
+        outputs = NamedValues()
+        # Fuel burn is negative of delta mass
+        outputs.set_val('Fuel Burn', fuel_burn, 'lbm')
+        outputs.set_val('Elapsed Time', time, 'min')
+        outputs.set_val('Ground Distance', range, 'nmi')
+        data[phase] = outputs
+
+        # get final values, last in traj
+        final_mass = _get_phase_value('traj', phase, 'mass', 'lbm', -1)[0]
+        final_time = _get_phase_value('traj', phase, 't', 'min', -1)
+        final_range = _get_phase_value('traj', phase, 'distance', 'nmi', -1)[0]
+
+    totals = NamedValues()
+    totals.set_val('Total Fuel Burn', initial_mass - final_mass, 'lbm')
+    totals.set_val('Total Time', final_time - initial_time, 'min')
+    totals.set_val('Total Ground Distance', final_range - initial_range, 'nmi')
+
+    if MPI and MPI.COMM_WORLD.rank != 0:
+        return
+
+    with open(report_file, mode='w') as f:
+        f.write('# MISSION SUMMARY')
+        write_markdown_variable_table(f, totals,
+                                      ['Total Fuel Burn',
+                                       'Total Time',
+                                       'Total Ground Distance'],
+                                      {'Total Fuel Burn': {'units': 'lbm'},
+                                       'Total Time': {'units': 'min'},
+                                       'Total Ground Distance': {'units': 'nmi'}})
+
+        f.write('\n# MISSION SEGMENTS')
+        for phase in data:
+            f.write(f'\n## {phase}')
+            write_markdown_variable_table(f, data[phase], ['Fuel Burn', 'Elapsed Time', 'Ground Distance'],
+                                          {'Fuel Burn': {'units': 'lbm'},
+                                           'Elapsed Time': {'units': 'min'},
+                                           'Ground Distance': {'units': 'nmi'}})

+
+
+
+

+[docs]
+def timeseries_csv(prob, **kwargs):
+    """
+    Generates a CSV file containing timeseries data for variables from an Aviary mission.
+
+    This function extracts timeseries data from the provided problem object, processes the data
+    to unify units across different phases of the mission, and then outputs the result to a CSV file.
+    The 'time' variable is moved to the beginning of the dataset so it's always the leftmost column.
+    Duplicate consecutive rows are eliminated.
+
+    Parameters
+    ----------
+    prob : AviaryProblem
+        The AviaryProblem used to generate this report
+    kwargs : dict
+        Additional keyword arguments (unused)
+
+    The output CSV file is named 'mission_timeseries_data.csv' and is saved in the reports directory.
+    The first row of the CSV file contains headers with variable names and units.
+    Each subsequent row represents the mission outputs at a different time step.
+    """
+    timeseries_outputs = prob.model.list_outputs(
+        includes='*timeseries*', out_stream=None, return_format='dict', units=True)
+    phase_names = prob.model.traj._phases.keys()
+
+    # There are no more collective calls, so we can exit.
+    if MPI and MPI.COMM_WORLD.rank != 0:
+        return
+
+    timeseries_outputs = {value['prom_name']: value for key,
+                          value in timeseries_outputs.items()}
+
+    timeseries_outputs = {key: value for key,
+                          value in timeseries_outputs.items() if not key.endswith('_phase')}
+
+    unique_variable_names = set([timeseries_output.split('.')[-1]
+                                for timeseries_output in timeseries_outputs])
+
+    timeseries_data = {}
+    for variable_name in unique_variable_names:
+        timeseries_data[variable_name] = {}
+        val_full_traj = np.zeros((0, 1))
+        units = None
+        for idx_phase, phase_name in enumerate(phase_names):
+            variable_str = f'traj.{phase_name}.timeseries.{variable_name}'
+            time_str = f'traj.{phase_name}.timeseries.time'
+
+            if variable_str not in timeseries_outputs:
+                Warning(
+                    f'Variable {variable_str} not found in timeseries_outputs for phase {phase_name}.')
+                val = np.zeros_like(timeseries_outputs[time_str]['val'])
+                val[:] = np.nan
+                val_full_traj = np.vstack((val_full_traj, val))
+
+            else:
+                val = timeseries_outputs[variable_str]['val']
+
+                # grab the units from the first phase that uses this variable; use these units for all others
+                if units is None:
+                    units = timeseries_outputs[variable_str]['units']
+                    val_full_traj = np.vstack((val_full_traj, val))
+                else:
+                    original_units = timeseries_outputs[variable_str]['units']
+
+                    if original_units != units:
+                        val = wrapped_convert_units((val, original_units), units)
+
+                    val_full_traj = np.vstack((val_full_traj, val))
+
+        timeseries_data[variable_name]['val'] = val_full_traj
+        timeseries_data[variable_name]['units'] = units
+        timeseries_data[variable_name]['shape'] = val_full_traj.shape
+
+    # Create a DataFrame from timeseries_data
+    df_data = {variable_name: pd.Series(timeseries_data[variable_name]['val'].flatten())
+               for variable_name in timeseries_data}
+    df = pd.DataFrame(df_data)
+
+    time_column = ['time']  # Isolate the 'time' column
+    # Sort the rest of the columns
+    other_columns = sorted([col for col in df.columns if col != 'time'])
+    columns = time_column + other_columns  # Combine them, keeping 'time' first
+    df = df[columns]
+
+    # Add units to column names
+    df.columns = [f'{col} ({timeseries_data[col]["units"]})' for col in df.columns]
+
+    df.drop_duplicates()
+
+    # The path where you want to save the CSV file
+    reports_folder = Path(prob.get_reports_dir())
+    report_file = reports_folder / 'mission_timeseries_data.csv'
+
+    # Write the DataFrame to a CSV file
+    df.to_csv(report_file, index=False)

+
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..5673e4ad3 --- /dev/null +++ b/_modules/aviary/utils/aero_table_conversion.html @@ -0,0 +1,755 @@ + + + + + + + + + + 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
+
+
+def _setup_ATC_parser(parser):
+    parser.add_argument('input_file', type=str,
+                        help='path to aero data 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')
+
+
+def _exec_ATC(args, user_args):
+    AeroDataConverter(**vars(args))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Converts FLOPS- or GASP-formatted '
+                                     'aero data files into Aviary csv format.\n')
+    _setup_ATC_parser(parser)
+    args = parser.parse_args()
+    _exec_ATC(args, None)
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..8bf82db7f --- /dev/null +++ b/_modules/aviary/utils/aviary_values.html @@ -0,0 +1,631 @@ + + + + + + + + + + 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..14f20f93f --- /dev/null +++ b/_modules/aviary/utils/compare_hierarchies.html @@ -0,0 +1,673 @@ + + + + + + + + + + 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..361f2d02f --- /dev/null +++ b/_modules/aviary/utils/conflict_checks.html @@ -0,0 +1,523 @@ + + + + + + + + + + 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..d48e8707a --- /dev/null +++ b/_modules/aviary/utils/csv_data_file.html @@ -0,0 +1,767 @@ + + + + + + + + + + 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..89e5d14ec --- /dev/null +++ b/_modules/aviary/utils/data_interpolator_builder.html @@ -0,0 +1,734 @@ + + + + + + + + + + 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..6a463844f --- /dev/null +++ b/_modules/aviary/utils/develop_metadata.html @@ -0,0 +1,674 @@ + + + + + + + + + + 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..40e06f8df --- /dev/null +++ b/_modules/aviary/utils/engine_deck_conversion.html @@ -0,0 +1,1327 @@ + + + + + + + + + + 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
+
+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'
+    GASP_TP = 'GASP_TP'
+
+    def __str__(self):
+        return self.value

+
+
+
+MACH = EngineModelVariables.MACH
+ALTITUDE = EngineModelVariables.ALTITUDE
+THROTTLE = EngineModelVariables.THROTTLE
+HYBRID_THROTTLE = EngineModelVariables.HYBRID_THROTTLE
+THRUST = EngineModelVariables.THRUST
+TAILPIPE_THRUST = EngineModelVariables.TAILPIPE_THRUST
+GROSS_THRUST = EngineModelVariables.GROSS_THRUST
+SHAFT_POWER_CORRECTED = EngineModelVariables.SHAFT_POWER_CORRECTED
+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, 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',
+    SHAFT_POWER_CORRECTED: 'Shaft_Power_Corrected',
+    TAILPIPE_THRUST: 'Tailpipe_Thrust',
+    # EXIT_AREA: 'Exit Area',
+}
+
+
+

+[docs]
+def EngineDeckConverter(input_file, output_file, data_format: EngineDeckType):
+    '''
+    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)
+    '''
+    # 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}')
+    legacy_code = data_format.value
+    engine_type = 'engine'
+    if legacy_code == 'GASP_TP':
+        engine_type = 'turboshaft engine'
+        legacy_code = 'GASP'
+
+    comments.append(
+        f'# {legacy_code}-derived {engine_type} 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 in (EngineDeckType.GASP, EngineDeckType.GASP_TP):
+        is_turbo_prop = True if data_format == EngineDeckType.GASP_TP else False
+        temperature = gasp_keys.pop()
+        fuelflow = gasp_keys.pop()
+        if is_turbo_prop:
+            gasp_keys.extend((SHAFT_POWER_CORRECTED, TAILPIPE_THRUST))
+        else:
+            gasp_keys.extend((THRUST))
+        gasp_keys.extend((fuelflow, temperature))
+
+        data = {key: [] for key in gasp_keys}
+
+        scalars, tables, fields = _read_gasp_engine(data_file, is_turbo_prop)
+        if 'throttle_type' in scalars:
+            throttle_type = scalars.pop('throttle_type')
+        else:
+            throttle_type = 1
+        t4max = scalars['t4max']
+        if t4max <= 100 or throttle_type == 3:
+            throttle_step = 2
+        else:
+            throttle_step = .05
+
+        # 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',
+                                                    fields=fields, throttle_step=throttle_step)
+
+            data[MACH] = structured_data['fuelflow']['machs']
+            data[ALTITUDE] = structured_data['fuelflow']['alts']
+            data[FUEL_FLOW] = structured_data['fuelflow']['vals']
+            T4T2 = structured_data['fuelflow']['t4t2s']
+            if is_turbo_prop:
+                data[SHAFT_POWER_CORRECTED] = structured_data['shaft_power_corrected']['vals']
+                data[TAILPIPE_THRUST] = structured_data['tailpipe_thrust']['vals']
+            else:
+                data[THRUST] = structured_data['thrust']['vals']
+
+        else:
+            data[MACH] = tables['fuelflow'][:, 2]
+            data[ALTITUDE] = tables['fuelflow'][:, 0]
+            data[FUEL_FLOW] = tables['fuelflow'][:, 3]
+            T4T2 = tables['fuelflow'][:, 1]
+            if is_turbo_prop:
+                data[SHAFT_POWER_CORRECTED] = tables['shaft_power_corrected'][:, 3]
+                data[TAILPIPE_THRUST] = tables['tailpipe_thrust'][:, 3]
+            else:
+                data[THRUST] = tables['thrust'][:, 3]
+
+        generate_flight_idle = True
+        if generate_flight_idle and not is_turbo_prop:
+            data, T4T2 = _generate_flight_idle(data, T4T2,
+                                               ref_sls_airflow=scalars['sls_airflow'],
+                                               ref_sfn_idle=scalars['sfn_idle'])
+
+        # if t4max 100 or less, it is actually throttle. Remove temperature as variable
+        if t4max <= 100 or throttle_type == 3:
+            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[FUEL_FLOW] = data[FUEL_FLOW][valid_idx]
+            data[TEMPERATURE] = data[TEMPERATURE][valid_idx]
+            if is_turbo_prop:
+                data[SHAFT_POWER_CORRECTED] = data[SHAFT_POWER_CORRECTED][valid_idx]
+                data[TAILPIPE_THRUST] = data[TAILPIPE_THRUST][valid_idx]
+            else:
+                data[THRUST] = data[THRUST][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, is_turbo_prop=False):
+    """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 for TurboFans or 
+    shaft_power_corrected, fuelflow, or tailpipe_thrust for TurboProps).
+    """
+    with open(fp, "r") as f:
+        if is_turbo_prop:
+            table_types = ["shaft_power_corrected", "fuelflow", "tailpipe_thrust"]
+            scalars = _read_tp_header(f)
+        else:
+            table_types = ["thrust", "fuelflow", "airflow"]
+            scalars = _read_header(f)
+
+        tables = {k: _read_table(f, is_turbo_prop) for k in table_types}
+
+    return scalars, tables, table_types
+
+
+def _read_tp_header(f):
+    """Read GASP engine deck header, returning the engine scalars in a dict"""
+    # file header: FORMAT(2I5,10X,6F10.4)
+    iread, iprint, t4max, t4mcl, t4mc, t4idle, xsfc, cexp = _parse(
+        f, [*_rep(2, (int, 5)), (None, 10), *_rep(6, (float, 10))]
+    )
+    # file header: FORMAT(7F10.4)
+    sls_hp, xncref, prop_rpm, gbx_rat, torque_lim, waslrf = _parse(
+        f, [*_rep(6, (float, 10))]
+    )
+
+    return {
+        "throttle_type": iread,
+        "t4max": t4max,
+        "t4cruise": t4mc,
+        "t4climb": t4mcl,
+        "t4flight_idle": t4idle,
+        "xsfc": xsfc,
+        "cexp": cexp,
+        "sls_horsepower": sls_hp,
+        "freeturbine_rpm": xncref,
+        "propeller_rpm": prop_rpm,
+        "gearbox_ratio": gbx_rat,
+        "torque_limit": torque_lim,
+        "sls_corrected_airflow": waslrf,
+    }
+
+
+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, is_turbo_prop=False):
+    """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 for TurboFans or 
+    shaft_power_corrected, fuelflow, or tailpipe_thrust for TurboProps).
+    """
+    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, is_turbo_prop)
+
+        # 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, is_turbo_prop=False):
+    """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
+    max_columns = 6
+
+    # point vals: FORMAT(10X,6F10.4,10X)
+    x = []
+    npts_remaining = npts
+    while npts_remaining > 0:
+        npts_to_read = min(max_columns, npts_remaining)
+        # remaining vals on wrapped line
+        x.extend(list(_parse(f, [(None, 10), *_rep(npts_to_read, (float, 10))])))
+        npts_remaining -= npts_to_read
+
+    map_data[:, 2] = np.tile(x, nline)
+
+    for j in range(nline):
+        npts_remaining = npts
+        npts_to_read = min(max_columns, npts_remaining)
+        # line (y) val then z vals: FORMAT(F10.4,6F10.1,10X,/(6F10.1,10X))
+        vals = list(_parse(f, [(float, 10), *_rep(npts_to_read, (float, 10))]))
+        y = vals[0]
+        z = vals[1:]
+        npts_remaining -= npts_to_read
+        while npts_remaining > 0:
+            npts_to_read = min(max_columns, npts_remaining)
+            # add remaining vals on warapped line
+            line_format = [*_rep(npts_to_read, (float, 10))]
+            if is_turbo_prop:
+                line_format = [(None, 10), *line_format]
+            z.extend(list(_parse(f, line_format)))
+            npts_remaining -= npts_to_read
+
+        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", fields=["thrust", "fuelflow", "airflow"], throttle_step=.05):
+    """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 = throttle_step
+    # 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['fuelflow'][:, 1]
+    tma = data['fuelflow'][:, 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 fields:
+        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

+

+
+
+
+def _setup_EDC_parser(parser):
+    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('-f', '--data_format', type=EngineDeckType, choices=list(EngineDeckType),
+                        help='data format used by input_file')
+
+
+def _exec_EDC(args, user_args):
+    EngineDeckConverter(
+        input_file=args.input_file,
+        output_file=args.output_file,
+        data_format=args.data_format
+    )
+
+
+EDC_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.'
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(EDC_description)
+    _setup_EDC_parser(parser)
+    args = parser.parse_args()
+    _exec_EDC(args, None)
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..1c8c92307 --- /dev/null +++ b/_modules/aviary/utils/fortran_to_aviary.html @@ -0,0 +1,1174 @@ + + + + + + + + + + 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
+"""
+
+import csv
+import re
+import getpass
+
+from datetime import datetime
+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, Verbosity
+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, verbosity=Verbosity.BRIEF):
+    '''
+    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, 'verbosity': verbosity}
+
+    fortran_deck: Path = get_path(fortran_deck, verbose=False)
+
+    timestamp = datetime.now().strftime('%m/%d/%y at %H:%M')
+    user = getpass.getuser()
+    comments = []
+
+    comments.append(f'# created {timestamp} by {user}')
+    comments.append(
+        f'# {legacy_code.value}-derived aircraft input deck converted from {fortran_deck.name}')
+
+    if out_file:
+        out_file = Path(out_file)
+    else:
+        name = fortran_deck.stem
+        out_file: Path = fortran_deck.parent.resolve().joinpath(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 not force:
+            raise RuntimeError(f'{out_file} already exists. Choose a new name or enable '
+                               '--force')
+        elif verbosity.value >= 1:
+            print(f'Overwriting existing file: {out_file.name}')
+
+    else:
+        # create any directories defined by the new filename if they don't already exist
+        out_file.parent.mkdir(parents=True, exist_ok=True)
+        if verbosity.value >= 2:
+            print('Writing to:', out_file)
+
+    # open the file in write mode
+    with open(out_file, 'w', newline='') as f:
+        writer = csv.writer(f)
+
+        # 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 = []
+
+    list_of_equivalent_aviary_names, var_ind = update_name(
+        alternate_names, current_namelist+var_name, vehicle_data['verbosity'])
+
+    # Fortran uses 1 indexing, Python uses 0 indexing
+    fortran_offset = 1 if current_namelist else 0
+    if var_ind is not None:
+        var_ind -= fortran_offset
+
+    for name in list_of_equivalent_aviary_names:
+        if not skip_variable:
+            if 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['verbosity'].value >= 2:
+            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, verbosity=Verbosity.BRIEF):
+    '''update_name will convert a Fortran name to a list of equivalent Aviary names.'''
+
+    if '(' in var_name:  # some GASP lists are given as individual elements
+        # get the target index
+        var_ind = int(var_name.split('(')[1].split(')')[0])
+        var_name = var_name.split('(')[0]  # remove the index formatting
+    else:
+        var_ind = None
+
+    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:
+                for altname in list_of_names:
+                    altname = altname.lower()
+                    if altname.endswith(var_name.lower()):
+                        all_equivalent_names.append(key)
+                        continue
+                    elif var_ind is not None and altname.endswith(f'{var_name.lower()}({var_ind})'):
+                        all_equivalent_names.append(key)
+                        var_ind = None
+                        continue
+
+    # if there are no equivalent variable names, return the original name
+    if len(all_equivalent_names) == 0:
+        if verbosity.value >= 2:
+            print('passing: ', var_name)
+        all_equivalent_names = [var_name]
+
+    return all_equivalent_names, var_ind

+
+
+
+

+[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, distance_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:
+            problem_type = 'fallout'
+            input_values.set_val('problem_type', [problem_type])
+            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], distance_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]])
+
+    res = input_values.get_val(Aircraft.Design.RESERVE_FUEL_ADDITIONAL, units='lbm')[0]
+    if res <= 0:
+        input_values.set_val(Aircraft.Design.RESERVE_FUEL_ADDITIONAL, [0], units='lbm')
+        input_values.set_val(Aircraft.Design.RESERVE_FUEL_FRACTION,
+                             [-res], units='unitless')
+    elif res >= 10:
+        input_values.set_val(Aircraft.Design.RESERVE_FUEL_FRACTION,
+                             [0], units='unitless')
+    else:
+        ValueError('"FRESF" is not valid between 0 and 10.')
+
+    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",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbosity",
+        type=Verbosity,
+        choices=list(Verbosity),
+        default=1,
+        help="Set level of print statements",
+    )
+    # parser.add_argument(
+    #     "-vv",
+    #     "--very_verbose",
+    #     action="store_true",
+    #     help="Enable debug print statements",
+    # )
+
+
+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
+
+    # convert verbosity from number to enum
+    verbosity = Verbosity(args.verbosity)
+
+    create_aviary_deck(filepath, args.legacy_code, args.defaults_deck,
+                       args.out_file, args.force, verbosity)
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..205c0019f --- /dev/null +++ b/_modules/aviary/utils/functions.html @@ -0,0 +1,936 @@ + + + + + + + + + + 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 pkg_resources
+
+from openmdao.utils.units import convert_units
+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
+from aviary.interface.download_models import get_model
+
+
+

+[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, attempt to find it in the models directory.
+    if not path.exists():
+        hangar_based_path = get_model(original_path)
+        if verbose:
+            print(
+                f"Unable to locate '{aviary_based_path}' as an Aviary package path, checking built-in models")
+        path = hangar_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

+
+
+
+

+[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)

+
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..1d4b2334d --- /dev/null +++ b/_modules/aviary/utils/merge_hierarchies.html @@ -0,0 +1,696 @@ + + + + + + + + + + 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..ab49ca35c --- /dev/null +++ b/_modules/aviary/utils/merge_variable_metadata.html @@ -0,0 +1,609 @@ + + + + + + + + + + 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..0fe74a7a3 --- /dev/null +++ b/_modules/aviary/utils/named_values.html @@ -0,0 +1,876 @@ + + + + + + + + + + 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..ee8518027 --- /dev/null +++ b/_modules/aviary/utils/options.html @@ -0,0 +1,537 @@ + + + + + + + + + + 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..c2ce33272 --- /dev/null +++ b/_modules/aviary/utils/preprocessors.html @@ -0,0 +1,831 @@ + + + + + + + + + + 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)
+        # only perform check if at least one passenger class is entered
+        if passenger_check > 0 and passenger_count != passenger_check:
+            raise om.AnalysisError(
+                f"ERROR: In preprocesssors.py: passenger_count ({passenger_count}) does not equal the sum of first class + business class + tourist class passengers (total of {passenger_check}).")
+
+    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..def38edac --- /dev/null +++ b/_modules/aviary/utils/process_input_decks.html @@ -0,0 +1,888 @@ + + + + + + + + + + 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, Verbosity
+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='', verbosity=Verbosity.BRIEF):
+    """
+    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('verbosity', val=verbosity)
+    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)
+
+    if isinstance(vehicle_deck, AviaryValues):
+        aircraft_values.update(vehicle_deck)
+        initial_guesses = {}
+    else:
+        vehicle_deck = get_path(vehicle_deck)
+        aircraft_values, initial_guesses = parse_inputs(vehicle_deck, aircraft_values)
+
+    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.
+    """
+    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
+    }
+    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 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 aircraft_values.get_val('verbosity').value >= 2:
+                print('Unused:', var_name, var_values, comment)
+
+    return aircraft_values, initial_guesses

+
+
+# TODO this should be a preprocessor, and tasks split to be specific to subsystem
+#      e.g. aero preprocessor, mass preprocessor, 2DOF preprocessor, etc.
+
+
+

+[docs]
+def update_GASP_options(aircraft_values: AviaryValues()):
+    """
+    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.
+
+    Returns
+    -------
+    tuple: Updated aircraft values and initial guesses.
+    """
+    # update the options that depend on variables
+    update_dependent_options(aircraft_values, dependent_options)
+
+    ## 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)
+
+    if aircraft_values.get_val('verbosity').value >= 2:
+        print('\nOptions')
+        for key in get_keys(aircraft_values):
+            val, units = aircraft_values.get_item(key)
+            print(key, val, units)
+
+    return aircraft_values

+
+
+
+

+[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(), initial_guesses):
+    """
+    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')
+    num_pax = aircraft_values.get_val(Aircraft.CrewPayload.NUM_PASSENGERS)
+    reserve_val = aircraft_values.get_val(
+        Aircraft.Design.RESERVE_FUEL_ADDITIONAL, units='lbm')
+    reserve_frac = aircraft_values.get_val(
+        Aircraft.Design.RESERVE_FUEL_FRACTION, units='unitless')
+
+    reserves = initial_guesses['reserves']
+    if reserves < 0.0:
+        raise ValueError(
+            'initial_guesses["reserves"] must be greater than or equal to 0.')
+    elif reserves == 0:
+        reserves += reserve_val
+        reserves += (reserve_frac * (num_pax * initial_guesses['fuel_burn_per_passenger_mile'] *
+                                     aircraft_values.get_val(Mission.Design.RANGE, units='NM')))
+    elif reserves < 10:
+        reserves *= (num_pax * initial_guesses['fuel_burn_per_passenger_mile'] *
+                     aircraft_values.get_val(Mission.Design.RANGE, units='NM'))
+
+    initial_guesses['reserves'] = reserves
+
+    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']
+
+    # 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))
+
+    if aircraft_values.get_val('verbosity').value >= 2:
+        print('\nInitial Guesses')
+        for key, value in initial_guesses.items():
+            print(key, value)
+
+    return 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}],
+]
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..688b83b7d --- /dev/null +++ b/_modules/aviary/utils/set_mass_defaults.html @@ -0,0 +1,792 @@ + + + + + + + + + + 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.Instruments.MASS_COEFFICIENT,
+        val=0.0736,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Hydraulics.FLIGHT_CONTROL_MASS_COEFFICIENT,
+        val=0.112,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Hydraulics.GEAR_MASS_COEFFICIENT,
+        val=0.14,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Avionics.MASS,
+        val=1959.0,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.AirConditioning.MASS_COEFFICIENT,
+        val=1.65,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.AntiIcing.MASS,
+        val=551.0,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Furnishings.MASS,
+        val=11192.0,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.CrewPayload.PASSENGER_SERVICE_MASS_PER_PASSENGER,
+        val=5.0,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.CrewPayload.WATER_MASS_PER_OCCUPANT,
+        val=3.0,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Design.EMERGENCY_EQUIPMENT_MASS,
+        val=50.0,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.CrewPayload.CATERING_ITEMS_MASS_PER_PASSENGER,
+        val=7.6,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuel.UNUSABLE_FUEL_MASS_COEFFICIENT,
+        val=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..805024810 --- /dev/null +++ b/_modules/aviary/variable_info/enums.html @@ -0,0 +1,703 @@ + + + + + + + + + + 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'
+    SOLVED_2DOF = 'solved_2DOF'

+
+
+
+

+[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
+
+    def __str__(self):
+        return str(self.value)

+
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ 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..1d8efc6b6 --- /dev/null +++ b/_modules/aviary/variable_info/functions.html @@ -0,0 +1,758 @@ + + + + + + + + + + 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..841602924 --- /dev/null +++ b/_modules/aviary/variable_info/options.html @@ -0,0 +1,553 @@ + + + + + + + + + + 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..c4d34cc36 --- /dev/null +++ b/_modules/aviary/variable_info/variables.html @@ -0,0 +1,1368 @@ + + + + + + + + + + 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_COEFFICIENT = 'aircraft:air_conditioning:mass_coefficient'
+        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'
+        CATERING_ITEMS_MASS_PER_PASSENGER = 'aircraft:crew_and_payload:catering_items_mass_per_passenger'
+
+        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_PER_PASSENGER = 'aircraft:crew_and_payload:passenger_service_mass_per_passenger'
+
+        PASSENGER_SERVICE_MASS_SCALER = \
+            'aircraft:crew_and_payload:passenger_service_mass_scaler'
+
+        TOTAL_PAYLOAD_MASS = 'aircraft:crew_and_payload:total_payload_mass'
+        WATER_MASS_PER_OCCUPANT = 'aircraft:crew_and_payload:water_mass_per_occupant'
+        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_INSTALLATION_LOSS = 'aircraft:design:compute_installation_loss'
+        COMPUTE_VTAIL_VOLUME_COEFF = 'aircraft:design:compute_vtail_volume_coeff'
+        DRAG_COEFFICIENT_INCREMENT = 'aircraft:design:drag_increment'
+        DRAG_POLAR = 'aircraft:design:drag_polar'
+
+        EMERGENCY_EQUIPMENT_MASS = 'aircraft:design:emergency_equipment_mass'
+        EMPTY_MASS = 'aircraft:design:empty_mass'
+        EMPTY_MASS_MARGIN = 'aircraft:design:empty_mass_margin'
+
+        EMPTY_MASS_MARGIN_SCALER = \
+            'aircraft:design:empty_mass_margin_scaler'
+
+        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 = '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_PROPELLER_TIP_SPEED = 'aircraft:design:max_propeller_tip_speed'
+        MAX_STRUCTURAL_SPEED = 'aircraft:design:max_structural_speed'
+        OPERATING_MASS = 'aircraft:design:operating_mass'
+        PART25_STRUCTURAL_CATEGORY = 'aircraft:design:part25_structural_category'
+        RESERVE_FUEL_ADDITIONAL = 'aircraft:design:reserve_fuel_additional'
+        RESERVE_FUEL_FRACTION = 'aircraft:design:reserve_fuel_fraction'
+        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'
+        NUM_ENGINES = 'aircraft:engine:num_engines'
+        NUM_FUSELAGE_ENGINES = 'aircraft:engine:num_fuselage_engines'
+        NUM_PROPELLER_BLADES = 'aircraft:engine:num_propeller_blades'
+        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'
+        PROPELLER_ACTIVITY_FACTOR = 'aircraft:engine:propeller_activity_factor'
+        PROPELLER_DIAMETER = 'aircraft:engine:propeller_diameter'
+        PROPELLER_INTEGRATED_LIFT_COEFFICIENT = 'aircraft:engine:propeller_integrated_lift_coefficient'
+        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_COEFFICIENT = 'aircraft:fuel:unusable_fuel_mass_coefficient'
+        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:
+        FLIGHT_CONTROL_MASS_COEFFICIENT = 'aircraft:hydraulics:flight_control_mass_coefficient'
+        GEAR_MASS_COEFFICIENT = 'aircraft:hydraulics:gear_mass_coefficient'
+        MASS = 'aircraft:hydraulics:mass'
+        MASS_SCALER = 'aircraft:hydraulics:mass_scaler'
+        SYSTEM_PRESSURE = 'aircraft:hydraulics:system_pressure'

+
+
+

+[docs]
+    class Instruments:
+        MASS = 'aircraft:instruments:mass'
+        MASS_COEFFICIENT = 'aircraft:instruments:mass_coefficient'
+        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'
+        # Not defined in metadata!
+        # 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'
+        INSTALLATION_LOSS_FACTOR = 'installation_loss_factor'
+        LIFT = 'lift'
+        MACH = 'mach'
+        MACH_RATE = 'mach_rate'
+        MASS = 'mass'
+        MASS_RATE = 'mass_rate'
+        NOX_RATE = 'nox_rate'
+        NOX_RATE_TOTAL = 'nox_rate_total'
+        PERCENT_ROTOR_RPM_CORRECTED = 'percent_rotor_rpm_corrected'
+        PROPELLER_TIP_SPEED = 'propeller_tip_speed'
+        SHAFT_POWER = 'shaft_power'
+        SHAFT_POWER_CORRECTED = 'shaft_power_corrected'
+        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'
+        RANGE_RESIDUAL_RESERVE = 'mission:constraints:range_residual_reserve'

+
+
+

+[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_BURNED = 'mission:summary:fuel_burned'
+        FUEL_FLOW_SCALER = 'mission:summary:fuel_flow_scaler'
+        GROSS_MASS = 'mission:summary:gross_mass'
+        RANGE = 'mission:summary:range'
+        RESERVE_FUEL_BURNED = 'mission:summary:reserve_fuel_burned'
+        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_MACH = 'mission:takeoff:final_mach'
+        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..142ffd778 --- /dev/null +++ b/_modules/aviary/variable_info/variables_in.html @@ -0,0 +1,561 @@ + + + + + + + + + + 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..20554034f --- /dev/null +++ b/_modules/index.html @@ -0,0 +1,520 @@ + + + + + + + + + + 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..b6544eae6 --- /dev/null +++ b/_sources/_srcdocs/packages/interface.md @@ -0,0 +1,12 @@ +--- +orphan: true +--- + +# aviary.interface + +- [cmd_entry_points](interface/cmd_entry_points.md) +- [download_models](interface/download_models.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/download_models.md b/_sources/_srcdocs/packages/interface/download_models.md new file mode 100644 index 000000000..09c332eac --- /dev/null +++ b/_sources/_srcdocs/packages/interface/download_models.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# download_models.py + +```{eval-rst} + .. automodule:: aviary.interface.download_models + :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..9474a9012 --- /dev/null +++ b/_sources/_srcdocs/packages/utils.md @@ -0,0 +1,23 @@ +--- +orphan: true +--- + +# aviary.utils + +- [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) +- [fortran_to_aviary](utils/fortran_to_aviary.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) +- [set_mass_defaults](utils/set_mass_defaults.md) 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/fortran_to_aviary.md b/_sources/_srcdocs/packages/utils/fortran_to_aviary.md new file mode 100644 index 000000000..3bb1b1ab7 --- /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/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/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..8193dae01 --- /dev/null +++ b/_sources/developer_guide/codebase_overview.md @@ -0,0 +1,15 @@ +# 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 diff --git a/_sources/developer_guide/coding_standards.md b/_sources/developer_guide/coding_standards.md new file mode 100644 index 000000000..619e12c7d --- /dev/null +++ b/_sources/developer_guide/coding_standards.md @@ -0,0 +1,42 @@ +# 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. + +### Controlling Display Levels +To make debugging issues easier, it is strongly recommended to make use of the `VERBOSITY` setting. This allows control over how much information is displayed to a user; too much information makes finding relevant information difficult and not enough information can make tracking difficult. `Brief` should be the default in most cases; however, `Quiet` should be the default for tests. + +## 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..523cbc8be --- /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/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/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..1c6347e79 --- /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/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/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/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/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/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/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/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/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/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/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/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_distance': 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': {'time': ([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_distance': 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': {'time': ([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_distance': 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': {'time': ([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.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..36baccb0f --- /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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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.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..44cf28a83 --- /dev/null +++ b/_sources/examples/coupled_aircraft_mission_optimization.ipynb @@ -0,0 +1,561 @@ +{ + "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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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.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(av.Mission.Summary.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": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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(av.Mission.Summary.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": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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(av.Mission.Summary.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": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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(av.Mission.Summary.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 (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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/_sources/examples/intro.md b/_sources/examples/intro.md new file mode 100644 index 000000000..abc285ef1 --- /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/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/level_2_detailed_takeoff_and_landing.md b/_sources/examples/level_2_detailed_takeoff_and_landing.md new file mode 100644 index 000000000..32dd460d0 --- /dev/null +++ b/_sources/examples/level_2_detailed_takeoff_and_landing.md @@ -0,0 +1,60 @@ +# Level 2 Detailed Takeoff and Landing + +```{note} +Here we discuss how to optimize the takeoff and landing sequences for aircraft using the Level 2 interface in Aviary. +If you need more precise control over the flight profile and the trajectory definition, please see the Level 3 interface detailed in [FLOPS Based Detailed Takeoff and Landing](../user_guide/FLOPS_based_detailed_takeoff_and_landing.ipynb). +That other example also computes the balanced field length for the aircraft using branching trajectories, which is not done here. +``` + +This doc page discusses how to use Aviary to perform detailed takeoff and landing simulations for aircraft using the Level 2 interface. +When we say "detailed takeoff and landing," this simply means that we model the aircraft trajectory in more detail than other simplified mission representations. +This means two main things: + +- We model the takeoff portion of flight using a series of phases, such as ground roll, rotation, and multiple climb phases. Similarly, we model the landing portion of flight using a series of phases, such as approach, flare, and touchdown. +- Instead of using the height-energy approximation for the aircraft equations of motion, we use the full two-degree-of-freedom (2DOF) equations of motion. This means that there is a notion of angle of attack and aircraft pitch within the flight dynamics equations. These mission methods are both detailed in the [Mission Analysis doc page.](../theory_guide/mission.md) + +These considerations allow us to model specific parts of the aircraft trajectory in more detail, which is especially useful for certain performance-based disciplinary analyses, such as acoustics and controls. + +## How we define the trajectories + +We use the `phase_info` object to define the trajectories. +We generally use polynomial controls of order 1 to simplify the optimization problem. +What this means is that the control variables (Mach and altitude) are linear within one phase. +You can increase the order of the polynomial control or set `use_polynomial_control` to `False` to have the optimizer control the values at every node. + +We add any constraints needed for the trajectory in the `constraints` argument passed inside of `user_options`. +Any arbitrary variable present in the phase ODE can be constrained. +You can use boundary or path constraints by setting the `type` argument in the constraint dict. + +We optimize mach and altitude using the `optimize_mach` and `optimize_altitude` flags. +You can choose to disable optimization of these variables by setting them to `False` for any phase. +Aviary internally handles the connections for Mach and altitude between the phases to ensure continuity in the trajectory. +You can choose how to enforce that the throttle value is between 0 and 1; solver bounded, with boundary constraints, or path constraints. + +Initial guesses are important to help the optimizer converge well. +These guesses are much more important for the 2DOF model than the height-energy model. + +In these examples we only model the takeoff and landing trajectories individually, not as part of a full mission. +This is because acoustic certification is typically done for these phases separately. +However, you can easily combine these phases into a comprehensive mission by adding the takeoff, flight, and landing phases to the mission in that order. +The `2DOF` mission method (not the `solved_2DOF` mission method used here) models the entire mission including takeoff and landing phases. + +## Defining the takeoff trajectory + +We follow the diagram below to model the takeoff trajectory, which includes the ground roll, rotation, liftoff, and climb phases. +We add constraints at specific points in the flight to ensure we hit certain altitudes and distances needed for acoustic certification. +P1 and P2 correspond to microphone locations for acoustic certification. + +```{note} +Each of the phases modeled in the takeoff trajectory use the solved 2DOF model *except* for phase AB which uses a specific ground roll model. +``` + +![Takeoff Trajectory](images/takeoff.png) + +## Defining the landing trajectory + +For the landing trajectory, we also follow a diagram that outlines the approach and touchdown phases. +This trajectory is simpler than the takeoff trajectory. +P3 corresponds to the microphone location used for acoustic certification. + +![Landing Trajectory](images/landing.png) \ No newline at end of file diff --git a/_sources/examples/more_advanced_example.ipynb b/_sources/examples/more_advanced_example.ipynb new file mode 100644 index 000000000..a51e026de --- /dev/null +++ b/_sources/examples/more_advanced_example.ipynb @@ -0,0 +1,397 @@ +{ + "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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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", + " 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(av.Mission.Summary.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.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": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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(av.Mission.Summary.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": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "from openmdao.core.problem import _clear_problem_names\n", + "_clear_problem_names() # need to reset these to simulate separate runs\n", + "from openmdao.utils.reports_system import clear_reports\n", + "clear_reports()" + ] + }, + { + "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.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(av.Mission.Summary.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": "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/_sources/examples/reserve_missions.md b/_sources/examples/reserve_missions.md new file mode 100644 index 000000000..a0e3a44d0 --- /dev/null +++ b/_sources/examples/reserve_missions.md @@ -0,0 +1,58 @@ +# Reserve Mission Examples + +The reserve mission examples are broken up into two sections: height-energy missions, and 2DOF missions. +By default Aviary uses a height-energy formulation unless you have specified otherwise. +Single phase reserves for fixed-time and fixed-range will be presented as well as an example of a multiphase reserve mission. +An overview of how to formulate a reserve mission is presented in [Reserve Mission User Guide](../user_guide/reserve_missions.md). + +All of the reserve mission examples are available in `aviary/examples/reserve_missions/` +The examples start with `run_basic_aviary_example.py` and add reserve phases. +The 2DOF examples use `aircraft_for_bench_GwGm` instead of `aircraft_for_bench_FwFm` and import the default two_dof phase_info instead of the `example_phase_info`. + +## Fixed Range Reserve + +The simplest example of a reserve mission implementation can be seen in fixed-range examples, which add a fixed-range cruise to the end of the basic mission. + +* Height Energy: `run_reserve_mission_fixedrange.py` +* Two Degree of Freedom: `run_2dof_reserve_mission_fixedrange.py` + +This is performed by making a copy the cruise `phase_info` object and adding `"reserve": True,` and `"target_distance": (200, 'km'),`. + +The results of this study are shown in the `traj_results_report.html`. +The first thing we review is the altitude plot. +This plot clearly shows that a reserve cruise phase was created at the end of the regular mission. +There is no climb phase in that reserve; we jump to cruising altitude and cruise for 200 km. + +![Altitude](images/fixed_range_cruise_altitude.png "Altitude vs. Time for Fixed Range Cruise Reserve Example") + +Additionally when looking at the mass and distance plots from the same study, we can see that the regular and reserve phases are connected properly. +There is no discontinuity between regular and reserve phases for either distance or mass. + +![Distance](images/fixed_range_cruise_distance.png "Distance vs. Time for Fixed Range Cruise Reserve Example") +![Mass](images/fixed_range_cruise_mass.png "Mass vs. Time for Fixed Range Cruise Reserve Example") + +## Fixed Time Reserve + +Similar to the fixed-range example, a simple fixed-time reserve mission is also provided. + +* Height Energy: `run_reserve_mission_fixedtime.py` +* Two Degree of Freedom: `run_2dof_reserve_mission_fixedtime.py` + +Again, we make a copy of the cruise phase from `phase_info` and then modify it by adding `"reserve": True,` and `"target_duration": (30, 'min'),`. +We have also removed other references to time in the reserve phase definition. +We do not list `initial_guesses:time`, `user_options:duration_bounds`, or `user_options:fixed_duration`. +All of these are set automatically when we set `target_duration`. + +## Multiphase Reserve Mission + +The last example reserve mission includes five phases: climb, cruise for distance, cruise for time, cruise for distance, descend. + +* Height Energy: `run_reserve_mission_multiphase.py` +* Two Degree of Freedom: `run_2dof_reserve_mission_multiphase.py` + +This demonstrates how to create an arbitrarily ordered set of phases for reserve, including climb and descent phases. +All of these reserve phases are tagged with `"reserve": True,`. + +Results from this mission can be seen in the figure below. +![Multiphase](images/multiphase_reserve.png "Distance vs. Time for Multiphase Reserve Example") +There are three distinct cruise segments and the added reserve climb and reserve descent show a more realistic flight profile for a diverted aircraft. diff --git a/_sources/examples/simple_mission_example.ipynb b/_sources/examples/simple_mission_example.ipynb new file mode 100644 index 000000000..e58b2ca63 --- /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.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.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 `height_energy` mission method and `FLOPS`-based mass and aero estimation methods.\n", + "We strongly suggest using the `height_energy` 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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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_distance\": 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\": {\"time\": ([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.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(av.Mission.Summary.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..838a6b3cb --- /dev/null +++ b/_sources/getting_started/input_csv_phase_info.md @@ -0,0 +1,109 @@ +# Vehicle Input .csv File and Phase_info Dictionary + +## Vehicle Input .csv File + +```{note} +This section is under development. +``` + +`initial_guesses` is a dictionary that contains values used to initialize the trajectory. It contains the following keys along with default values: + +- 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 + +The initial guess of `reserves` is used to define the reserve fuel. Initially, its value can be anything larger than or equal to 0. There are two Aviary variables to control the reserve fuel in the model file (`.csv`): +- `Aircraft.Design.RESERVE_FUEL_ADDITIONAL`: the required fuel reserves: directly in lbm, +- `Aircraft.Design.RESERVE_FUEL_FRACTION`: the required fuel reserves: given as a proportion of mission fuel. + +If the value of initial guess of `reserves` (also in the model file if any) is 0, the initial guess of reserve fuel comes from the above two Aviary variables. Otherwise, it is determined by the parameter `reserves`: +- if `reserves > 10`, we assume it is the actual fuel reserves. +- if `0.0 <= reserves <= 10`, we assume it is the fraction of the mission fuel. + +The initial guess of `reserves` is always converted to the actual design reserves (instead of reserve factor) and is used to update the initial guesses of `fuel_burn_per_passenger_mile` and `cruise_mass_final`. + +## 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: + - We use `final_altitude` to indicate the final altitude of the phase. + - 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. + - `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`. + - `solve_for_distance`: if True, use a nonlinear solver to converge the `distance` state variable to the desired value. Otherwise use the optimizer to converge the `distance` state. + - `optimize_mach`: if True, the Mach number is a design variable. + - `optimize_altitude`: if True, the altitude is a design variable. + - `constraints`: a dictionary of user-defined constraints. The keys are the names of the constraints and the values are the keyword arguments expected by Dymos. + +```{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/Aviary/blob/main/aviary/interface/utils.py) function. Currently, this function does the check only for `FLOPS` and `GASP` missions. +``` + +## Using custom phase builders + +For the `height_energy`, you can use a user-defined phase builder. +The user-defined phase builder must inherit from `PhaseBuilderBase` and provide the `from_phase_info` and the `build_phase` methods. +The `from_phase_info` method is used to convert the `phase_info` dictionary into the inputs needed for the phase builder object. +The `build_phase` method is used to actually build and output the `Phase` object. + +For examples of how to create a custom phase builder, see the `energy_phase.py` file. + +```{note} +Using custom phase builders is a particularly advanced feature and is not recommended for most users. +``` diff --git a/_sources/getting_started/installation.md b/_sources/getting_started/installation.md new file mode 100644 index 000000000..faa9ab8e7 --- /dev/null +++ b/_sources/getting_started/installation.md @@ -0,0 +1,284 @@ +# 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 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 -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. +``` + +```{note} +You can install the optional package [pyOptSparse by following the instructions here](https://mdolab-pyoptsparse.readthedocs-hosted.com/en/latest/install.html). If you do not need the SNOPT optimizer, installing pyOptSparse is as simple as running `conda install -c conda-forge pyoptsparse`. +``` + +## 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 + - 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. 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`. +If you want to easily install and use pyOptSparse, follow the [installation instructions on the pyOptSparse docs](https://mdolab-pyoptsparse.readthedocs-hosted.com/en/latest/install.html). +Specifically, if you do not need the SNOPT optimizer and want to run Aviary with IPOPT, you can install pyOptSparse using the following command: + +``` +conda install -c conda-forge 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/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 . +``` + +When it is done, let us run test: + +``` +$ 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..4db2ba9d4 --- /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_height_energy_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.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.csv', av.default_height_energy_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.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/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.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.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.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_distance': 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': {'time': ([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_distance': 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': {'time': ([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_distance': 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': {'time': ([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.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..95e679e1f --- /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 `simple`.\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 `velocity_lower: (0, 'kn')`, `velocity_upper: (1000, 'kn')`, and `velocity_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](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_details/n2_details.html), sometimes referred to as an eXtended Design Structure Matrix (XDSM), is a powerful tool for understanding your model 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. MDO lab has another resource for learning about N2 and [XDSM](https://mdolab-pyxdsm.readthedocs-hosted.com/).\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..a7dff0021 --- /dev/null +++ b/_sources/getting_started/onboarding_level2.ipynb @@ -0,0 +1,772 @@ +{ + "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", + "from copy import deepcopy\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", + "phase_info = deepcopy(av.default_2DOF_phase_info)\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", + "# 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": [ + "phase_info = deepcopy(av.default_2DOF_phase_info)\n", + "prob.load_inputs(aircraft_filename, 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\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. An aircraft model can also be directly defined in Python, by setting up an `AviaryValues` object with the desired inputs and options normally found in an input file. That object can be provided in the place of `aircraft_filename`.\n", + "\n", + "\n", + "Engines are 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", + "Users can provide an `EngineModel` instance of their own to use in Aviary's propulsion systems by adding it to `engine_models`.\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 `simple` 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`, `simple`, 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 `simple` 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(\"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", + " 'optimize_mach': False,\n", + " 'optimize_altitude': False,\n", + " 'polynomial_control_order': 1,\n", + " 'num_segments': 2,\n", + " 'order': 3,\n", + " 'solve_for_distance': False,\n", + " 'initial_mach': (0.72, 'unitless'),\n", + " 'final_mach': (0.72, 'unitless'),\n", + " 'mach_bounds': ((0.7, 0.74), 'unitless'),\n", + " 'initial_altitude': (35000.0, 'ft'),\n", + " 'final_altitude': (35000.0, 'ft'),\n", + " 'altitude_bounds': ((23000.0, 38000.0), 'ft'),\n", + " 'throttle_enforcement': 'boundary_constraint',\n", + " 'fix_initial': True,\n", + " 'constrain_final': False,\n", + " 'fix_duration': False,\n", + " 'initial_bounds': ((0.0, 0.0), 'min'),\n", + " 'duration_bounds': ((10., 30.), 'min'),\n", + " },\n", + " 'initial_guesses': {'time': ([0, 30], 'min')},\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 = \"height_energy_energy\"\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](../user_guide/subsystems.md), which is one of the main features of the Aviary tool. [Examples](../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`.\n", + "\n", + "We will cover external subsystems in details in [Models with External Subsystems](onboarding_ext_subsystem.ipynb) page.\n" + ] + }, + { + "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", + "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.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..49c9136b6 --- /dev/null +++ b/_sources/getting_started/onboarding_level3.ipynb @@ -0,0 +1,601 @@ +{ + "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", + "\n", + "import dymos as dm\n", + "import openmdao.api as om\n", + "import scipy.constants as _units\n", + "\n", + "import aviary.api as av\n", + "from aviary.validation_cases.validation_tests import get_flops_inputs\n", + "\n", + "\n", + "prob = om.Problem(model=om.Group())\n", + "driver = prob.driver = om.pyOptSparseDriver()\n", + "driver.options[\"optimizer\"] = \"IPOPT\"\n", + "driver.opt_settings[\"max_iter\"] = 100\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 = get_flops_inputs('N3CC')\n", + "\n", + "aviary_inputs.set_val(av.Mission.Landing.LIFT_COEFFICIENT_MAX,\n", + " 2.4, units=\"unitless\")\n", + "aviary_inputs.set_val(av.Mission.Takeoff.LIFT_COEFFICIENT_MAX,\n", + " 2.0, units=\"unitless\")\n", + "aviary_inputs.set_val(\n", + " av.Mission.Takeoff.ROLLING_FRICTION_COEFFICIENT,\n", + " val=.0175, units=\"unitless\")\n", + "\n", + "takeoff_fuel_burned = 577 # lbm TODO: where should this get connected from?\n", + "takeoff_thrust_per_eng = 24555.5 # lbf TODO: where should this get connected from?\n", + "takeoff_L_over_D = 17.35 # TODO: should this come from aero?\n", + "\n", + "aviary_inputs.set_val(av.Mission.Takeoff.FUEL_SIMPLE,\n", + " takeoff_fuel_burned, units='lbm')\n", + "aviary_inputs.set_val(av.Mission.Takeoff.LIFT_OVER_DRAG,\n", + " takeoff_L_over_D, units=\"unitless\")\n", + "aviary_inputs.set_val(av.Mission.Design.THRUST_TAKEOFF_PER_ENG,\n", + " takeoff_thrust_per_eng, units='lbf')\n", + "\n", + "alt_airport = 0 # ft\n", + "cruise_mach = 0.79\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", + "# 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", + "cruise_mach = 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", + "mach_i_descent = 0.79\n", + "mach_f_descent = 0.3\n", + "mass_i_descent = 102000*_units.pound\n", + "mass_f_descent = 101000*_units.pound\n", + "distance_i_descent = 3243.9*_units.nautical_mile\n", + "distance_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", + "# Design Variables #\n", + "##########################\n", + "\n", + "# Nudge it a bit off the correct answer to verify that the optimize takes us there.\n", + "aviary_inputs.set_val(av.Mission.Design.GROSS_MASS, 135000.0, units='lbm')\n", + "\n", + "prob.model.add_design_var(av.Mission.Design.GROSS_MASS, units='lbm',\n", + " lower=100000.0, upper=200000.0, ref=135000)\n", + "\n", + "takeoff_options = av.HeightEnergyTakeoffPhaseBuilder(\n", + " airport_altitude=alt_airport, # ft\n", + " # no units\n", + " num_engines=aviary_inputs.get_val(av.Aircraft.Engine.NUM_ENGINES)\n", + ")\n", + "\n", + "##################\n", + "# Define Phases #\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.HeightEnergyPhaseBuilder(\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", + " 'input_initial': (True, 'unitless'),\n", + " 'use_polynomial_control': (False, '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.HeightEnergyPhaseBuilder(\n", + " 'test_cruise',\n", + " user_options=av.AviaryValues({\n", + " 'initial_altitude': (alt_min_cruise, 'm'),\n", + " 'final_altitude': (alt_max_cruise, 'm'),\n", + " 'initial_mach': (cruise_mach, 'unitless'),\n", + " 'final_mach': (cruise_mach, 'unitless'),\n", + " 'required_available_climb_rate': (300, 'ft/min'),\n", + " 'fix_initial': (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.HeightEnergyPhaseBuilder(\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", + " 'use_polynomial_control': (False, '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(av.Aircraft.Wing.AREA, units='ft**2'),\n", + " Cl_max_ldg=aviary_inputs.get_val(\n", + " av.Mission.Landing.LIFT_COEFFICIENT_MAX) # no units\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", + "# 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(fix_initial=True, fix_duration=False, units='s',\n", + " duration_bounds=(t_duration_climb*0.5, t_duration_climb*2),\n", + " duration_ref=t_duration_climb)\n", + "cruise.set_time_options(fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(t_duration_cruise*0.5, t_duration_cruise*2),\n", + " duration_ref=t_duration_cruise,\n", + " initial_bounds=(t_duration_climb*0.5, t_duration_climb*2))\n", + "descent.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(t_duration_descent*0.5, t_duration_descent*2),\n", + " duration_ref=t_duration_descent,\n", + " initial_bounds=(\n", + " (t_duration_cruise + t_duration_climb)*0.5,\n", + " (t_duration_cruise + t_duration_climb)*2))\n", + "\n", + "traj.add_phase('climb', climb)\n", + "\n", + "traj.add_phase('cruise', cruise)\n", + "\n", + "traj.add_phase('descent', descent)\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\", \"descent\"], [\"time\", av.Dynamic.Mission.MASS, av.Dynamic.Mission.DISTANCE], 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", + "prob.model.connect(av.Mission.Takeoff.FINAL_MASS,\n", + " 'traj.climb.initial_states:mass')\n", + "prob.model.connect(av.Mission.Takeoff.GROUND_DISTANCE,\n", + " 'traj.climb.initial_states:distance')\n", + "\n", + "prob.model.connect('traj.descent.states:mass',\n", + " av.Mission.Landing.TOUCHDOWN_MASS, src_indices=[-1])\n", + "# TODO: approach velocity should likely be connected\n", + "prob.model.connect('traj.descent.control_values:altitude', av.Mission.Landing.INITIAL_ALTITUDE,\n", + " src_indices=[-1])\n", + "\n", + "##########################\n", + "# Constraints #\n", + "##########################\n", + "\n", + "ecomp = om.ExecComp('fuel_burned = initial_mass - descent_mass_final',\n", + " initial_mass={'units': 'lbm', 'shape': 1},\n", + " descent_mass_final={'units': 'lbm', 'shape': 1},\n", + " fuel_burned={'units': 'lbm', 'shape': 1})\n", + "\n", + "prob.model.add_subsystem('fuel_burn', ecomp,\n", + " promotes_inputs=[\n", + " ('initial_mass', av.Mission.Design.GROSS_MASS)],\n", + " promotes_outputs=['fuel_burned'])\n", + "\n", + "prob.model.connect(\"traj.descent.states:mass\",\n", + " \"fuel_burn.descent_mass_final\", src_indices=[-1])\n", + "\n", + "# TODO: need to add some sort of check that this value is less than the fuel capacity\n", + "# TODO: need to update this with actual FLOPS value, this gives unrealistic\n", + "# appearance of accuracy\n", + "# TODO: the overall_fuel variable is the burned fuel plus the reserve, but should\n", + "# also include the unused fuel, and the hierarchy variable name should be more clear\n", + "ecomp = om.ExecComp('overall_fuel = fuel_burned + fuel_reserve',\n", + " fuel_burned={'units': 'lbm', 'shape': 1},\n", + " fuel_reserve={'units': 'lbm', 'val': 2173.},\n", + " overall_fuel={'units': 'lbm'})\n", + "prob.model.add_subsystem('fuel_calc', ecomp,\n", + " promotes_inputs=['fuel_burned'],\n", + " promotes_outputs=['overall_fuel'])\n", + "\n", + "ecomp = om.ExecComp(\n", + " 'mass_resid = operating_empty_mass + overall_fuel + payload_mass '\n", + " '- initial_mass',\n", + " operating_empty_mass={'units': 'lbm'},\n", + " overall_fuel={'units': 'lbm'},\n", + " payload_mass={'units': 'lbm'},\n", + " initial_mass={'units': 'lbm'},\n", + " mass_resid={'units': 'lbm'})\n", + "\n", + "prob.model.add_subsystem(\n", + " 'mass_constraint', ecomp,\n", + " promotes_inputs=[\n", + " ('operating_empty_mass', av.Aircraft.Design.OPERATING_MASS),\n", + " 'overall_fuel',\n", + " ('payload_mass', av.Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS),\n", + " ('initial_mass', av.Mission.Design.GROSS_MASS)],\n", + " promotes_outputs=['mass_resid'])\n", + "\n", + "prob.model.add_constraint('mass_resid', equals=0.0, ref=1.0)\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 (making each of the sub-objectives approx = 1 )\n", + "# TODO: change the scaling on climb_duration\n", + "prob.model.add_subsystem(\n", + " \"regularization\",\n", + " om.ExecComp(\n", + " \"reg_objective = fuel_mass/1500\",\n", + " reg_objective=0.0,\n", + " fuel_mass={\"units\": \"lbm\", \"shape\": 1},\n", + " ),\n", + " promotes_outputs=['reg_objective']\n", + ")\n", + "# connect the final mass from cruise into the objective\n", + "prob.model.connect(av.Mission.Design.FUEL_MASS, \"regularization.fuel_mass\")\n", + "\n", + "prob.model.add_objective('reg_objective', ref=1)\n", + "\n", + "# Set initial default values for all LEAPS aircraft variables.\n", + "av.set_aviary_initial_values(prob.model, aviary_inputs)\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(force_alloc_complex=True)\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.controls:altitude', climb.interp(\n", + " av.Dynamic.Mission.ALTITUDE, ys=[alt_i_climb, alt_f_climb]), units='m')\n", + "prob.set_val(\n", + " 'traj.climb.controls:mach', climb.interp(\n", + " av.Dynamic.Mission.MACH, ys=[mach_i_climb, mach_f_climb]), units='unitless')\n", + "prob.set_val('traj.climb.states:mass', climb.interp(\n", + " av.Dynamic.Mission.MASS, ys=[mass_i_climb, mass_f_climb]), units='kg')\n", + "prob.set_val('traj.climb.states:distance', climb.interp(\n", + " av.Dynamic.Mission.DISTANCE, ys=[range_i_climb, range_f_climb]), units='m')\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.polynomial_controls:altitude', cruise.interp(\n", + " av.Dynamic.Mission.ALTITUDE, ys=[alt_i_cruise, alt_f_cruise]), units='m')\n", + "prob.set_val(\n", + " 'traj.cruise.polynomial_controls:mach', cruise.interp(\n", + " av.Dynamic.Mission.MACH, ys=[cruise_mach, cruise_mach]), units='unitless')\n", + "prob.set_val('traj.cruise.states:mass', cruise.interp(\n", + " av.Dynamic.Mission.MASS, ys=[mass_i_cruise, mass_f_cruise]), units='kg')\n", + "prob.set_val('traj.cruise.states:distance', cruise.interp(\n", + " av.Dynamic.Mission.DISTANCE, ys=[range_i_cruise, range_f_cruise]), units='m')\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.controls:altitude', descent.interp(\n", + " av.Dynamic.Mission.ALTITUDE, ys=[alt_i_descent, alt_f_descent]), units='m')\n", + "prob.set_val(\n", + " 'traj.descent.controls:mach', descent.interp(\n", + " av.Dynamic.Mission.MACH, ys=[mach_i_descent, mach_f_descent]), units='unitless')\n", + "prob.set_val('traj.descent.states:mass', descent.interp(\n", + " av.Dynamic.Mission.MASS, ys=[mass_i_descent, mass_f_descent]), units='kg')\n", + "prob.set_val('traj.descent.states:distance', descent.interp(\n", + " av.Dynamic.Mission.DISTANCE, ys=[distance_i_descent, distance_f_descent]), units='m')\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='N3CC_sizing.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.altitude', units='m')\n", + "masses_climb = prob.get_val('traj.climb.timeseries.mass', units='kg')\n", + "ranges_climb = prob.get_val('traj.climb.timeseries.distance', units='m')\n", + "velocities_climb = prob.get_val(\n", + " 'traj.climb.timeseries.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.altitude', units='m')\n", + "masses_cruise = prob.get_val('traj.cruise.timeseries.mass', units='kg')\n", + "ranges_cruise = prob.get_val('traj.cruise.timeseries.distance', units='m')\n", + "velocities_cruise = prob.get_val(\n", + " 'traj.cruise.timeseries.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.altitude', units='m')\n", + "masses_descent = prob.get_val('traj.descent.timeseries.mass', units='kg')\n", + "ranges_descent = prob.get_val('traj.descent.timeseries.distance', units='m')\n", + "velocities_descent = prob.get_val(\n", + " 'traj.descent.timeseries.velocity', units='m/s')\n", + "thrusts_descent = prob.get_val(\n", + " 'traj.descent.timeseries.thrust_net_total', units='N')\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": "2b43d293", + "metadata": {}, + "source": [ + "This model demonstrates the flexibility of level 3. For example, we do 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 = get_flops_inputs('LargeSingleAisle1FLOPS')\n", + "aviary_inputs = get_flops_inputs('LargeSingleAisle2FLOPS')\n", + "aviary_inputs = get_flops_inputs('LargeSingleAisle2FLOPSdw')\n", + "aviary_inputs = 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..acf630706 --- /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/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/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..0904749a4 --- /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/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/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..b99412cbc --- /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).\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..5bed0564d --- /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). 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..2f9bc319f --- /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) and [hierarchies](../user_guide/variable_hierarchy) 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 +} 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..e652c3d48 --- /dev/null +++ b/_sources/user_guide/FLOPS_based_detailed_takeoff_and_landing.ipynb @@ -0,0 +1,603 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "01c83833", + "metadata": {}, + "source": [ + "# FLOPS Based Detailed Takeoff and Landing\n", + "\n", + "```{note}\n", + "This doc page details the Level 3 API for FLOPS-based detailed takeoff and landing. This is useful for advanced users who want to model these flight phases and have supreme control over how the problem is set up. For a simpler and slightly more limited experience, please see the Level 2 takeoff and landing examples.\n", + "```\n", + "\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('distance_max', 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('time', [0., 30.], 's')\n", + "takeoff_brake_release_initial_guesses.set_val('distance', [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", + "distance_max, units = takeoff_liftoff_user_options.get_item('distance_max')\n", + "liftoff = takeoff_trajectory_builder.get_phase('takeoff_liftoff')\n", + "\n", + "liftoff.add_objective(\n", + " Dynamic.Mission.DISTANCE, loc='final', ref=distance_max, 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('distance_max', 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('time', [-42., 15.], 's')\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('distance', [-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", + "distance_max, units = landing_fullstop_user_options.get_item('distance_max')\n", + "fullstop = landing_trajectory_builder.get_phase('landing_fullstop')\n", + "\n", + "fullstop.add_objective(Dynamic.Mission.DISTANCE, loc='final', ref=distance_max, 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..18a25ca75 --- /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.8.17" + } + }, + "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..aa34c6053 --- /dev/null +++ b/_sources/user_guide/aviary_commands.ipynb @@ -0,0 +1,332 @@ +{ + "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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(aviary-hangar-command)=\n", + "### aviary hangar\n", + "\n", + "The `aviary hangar` command will copy files and folders from the Aviary hangar to an accessible directory.\n", + "This is useful for users that have pip installed Aviary, but want to experiment with the included examples.\n", + "\n", + "The only required input is the name of an input deck.\n", + "This can be specified as the name of the file, the path from [aviary/models](https://github.com/OpenMDAO/Aviary/tree/main/aviary/models), the name of a folder in aviary/models. Multiple files and folders can be copied at once.\n", + "Optionally, the output directory can be specified; if it is not, the files will be copied into the current working directory in a folder called aviary_models.\n", + "If specified, the output directory will be created as needed.\n", + "\n", + "Example usage:\n", + "```\n", + "`aviary hangar engines` Copy all files in the engines folder\n", + "`aviary hangar turbofan_22k.txt` Copy the 22k turbofan deck\n", + "`aviary hangar N3CC/N3CC_data.py` Copy the N3CC data\n", + "`aviary hangar small_single_aisle_GwGm.dat small_single_aisle_GwGm.csv` Copy the Fortran and Aviary input decks for the small single aisle\n", + "`aviary hangar turbofan_22k.txt ~/example_files` Copy the engine model into ~/example_files\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "aviary hangar -h\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!aviary hangar -h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(aviary-EDC-command)=\n", + "### aviary convert_engine\n", + "\n", + "The `aviary convert_engine` command will convert a legacy formatted (FLOPS or GASP) engine deck into an Aviary formatted engine deck.\n", + "\n", + "Users must provide the path or name of an input deck, the path to the output file, and the engine format being converted.\n", + "If an invalid filepath is given for the input file, pre-packaged resources will be checked for input decks with a matching name.\n", + "\n", + "Notes for input decks:\n", + "- TurboFan decks for both FLOPS and GASP can be converted\n", + "- TurboProp decks for GASP can also be converted\n", + "- Comments can be added using #\n", + "\n", + "\n", + "Example usage:\n", + "```\n", + "`aviary convert_engine GASP_turbofan_23k_1.eng turbofan_23k_1_lbm_s.deck GASP` Convert a GASP based turbofan\n", + "`aviary convert_engine turbofan_22k.eng turbofan_22k.txt FLOPS` Convert a FLOPS based turbofan\n", + "`aviary convert_engine turboprop_4465hp.eng turboprop_4465hp.deck GASP_TP` Convert a GASP based turboprop\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "aviary convert_engine -h\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!aviary convert_engine -h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(aviary-ATC-command)=\n", + "### aviary convert_aero_table\n", + "\n", + "The `aviary convert_aero_table` command will convert a legacy formatted (FLOPS or GASP) aero table into an Aviary formatted aero table.\n", + "\n", + "Users must provide the path or name of an input deck and the data format being converted.\n", + "Optionally, the path to the output file can also be specified, otherwise the default output file will be in the same location and have the same name as input file, but with '_aviary' appended to filename.\n", + "If an invalid filepath is given for the input file, pre-packaged resources will be checked for input decks with a matching name.\n", + "\n", + "Notes for input decks:\n", + "- Aero tables for both FLOPS and GASP can be converted\n", + "- GASP tables will create a single file containing all the lift and drag information\n", + "- FLOPS tables will create two files, one containing the lift-dependent drag and the other containing the lift-independent drag.\n", + "- Comments can be added using #\n", + "\n", + "\n", + "Example usage:\n", + "```\n", + "`aviary convert_engine GASP_turbofan_23k_1.eng turbofan_23k_1_lbm_s.deck GASP` Convert a GASP based turbofan\n", + "`aviary convert_engine turbofan_22k.eng turbofan_22k.txt FLOPS` Convert a FLOPS based turbofan\n", + "`aviary convert_engine turboprop_4465hp.eng turboprop_4465hp.deck GASP_TP` Convert a GASP based turboprop\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "aviary convert_aero_table -h\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!aviary convert_aero_table -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..21faef03d --- /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/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/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..5a5b02580 --- /dev/null +++ b/_sources/user_guide/drawing_and_running_simple_missions.md @@ -0,0 +1,92 @@ +# 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. + +```{note} +If you are [WSL on Windows](https://learn.microsoft.com/en-us/windows/wsl/install) you might need to install an [X Server](https://sourceforge.net/projects/xming/) to run the GUI without issues. If you do this, also modify your `.bashrc` file to include this line: `export DISPLAY=localhost:0.0`. +``` + +## 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. + +```{note} +When using the outputted `phase_info` dict in a mission simulation, you can modify the settings by directly changing the outputted Python file. +``` + +The `phase_info` dictionary makes some assumptions about different settings which you can also modify. +For example, the time duration of each phase is controlled by the optimizer if `fix_duration` is False, though this can be changed to True to fix the duration of each phase. + +## 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..a16a2f165 --- /dev/null +++ b/_sources/user_guide/examples_of_the_same_mission_at_different_UI_levels.ipynb @@ -0,0 +1,483 @@ +{ + "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": [ + "import aviary.api as av\n", + "\n", + "phase_info = {\n", + " \"pre_mission\": {\"include_takeoff\": False, \"optimize_mass\": True},\n", + " \"climb\": {\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_distance\": 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", + " \"add_initial_mass_constraint\": False,\n", + " },\n", + " \"initial_guesses\": {\"time\": ([0, 128], \"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_distance\": 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\": {\"time\": ([128, 113], \"min\")},\n", + " },\n", + " \"descent\": {\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_distance\": 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\": {\"time\": ([241, 58], \"min\")},\n", + " },\n", + " \"post_mission\": {\n", + " \"include_landing\": False,\n", + " \"constrain_range\": True,\n", + " \"target_range\": (1906, \"nmi\"),\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", + "\n", + "import aviary.api as av\n", + "\n", + "\n", + "prob = om.Problem(model=om.Group())\n", + "driver = prob.driver = om.ScipyOptimizeDriver()\n", + "driver.options[\"optimizer\"] = \"SLSQP\"\n", + "driver.options[\"maxiter\"] = 1\n", + "\n", + "##########################################\n", + "# Aircraft Input Variables and Options #\n", + "##########################################\n", + "\n", + "csv_path = \"models/test_aircraft/aircraft_for_bench_FwFm.csv\"\n", + "\n", + "aviary_inputs, _ = av.create_vehicle('models/test_aircraft/aircraft_for_bench_FwFm.csv')\n", + "\n", + "engine = av.EngineDeck(options=aviary_inputs)\n", + "av.preprocess_propulsion(aviary_inputs, [engine])\n", + "\n", + "alt_airport = 0 # ft\n", + "\n", + "alt_i_climb = 0*_units.foot # m\n", + "alt_f_climb = 32000.0*_units.foot # m\n", + "mass_i_climb = 131000*_units.lb # kg\n", + "mass_f_climb = 126000*_units.lb # kg\n", + "mach_i_climb = 0.2\n", + "mach_f_climb = 0.72\n", + "distance_i_climb = 0*_units.nautical_mile # m\n", + "distance_f_climb = 160.3*_units.nautical_mile # m\n", + "t_i_climb = 0. * _units.minute # sec\n", + "t_f_climb = 128 * _units.minute # sec\n", + "t_duration_climb = t_f_climb - t_i_climb\n", + "\n", + "alt_i_cruise = 32000*_units.foot # m\n", + "alt_f_cruise = 34000*_units.foot # m\n", + "alt_min_cruise = 32000*_units.foot # m\n", + "alt_max_cruise = 34000*_units.foot # m\n", + "mass_i_cruise = 126000*_units.lb # kg\n", + "mass_f_cruise = 102000*_units.lb # kg\n", + "cruise_mach = 0.79\n", + "distance_i_cruise = 160.3*_units.nautical_mile # m\n", + "distance_f_cruise = 3243.9*_units.nautical_mile # m\n", + "t_i_cruise = 128. * _units.minute # sec\n", + "t_f_cruise = 241. * _units.minute # sec\n", + "t_duration_cruise = t_f_cruise - t_i_cruise\n", + "\n", + "alt_i_descent = 34000*_units.foot\n", + "alt_f_descent = 500*_units.foot\n", + "mach_i_descent = 0.72\n", + "mach_f_descent = 0.3\n", + "mass_i_descent = 102000*_units.pound\n", + "mass_f_descent = 101000*_units.pound\n", + "distance_i_descent = 3243.9*_units.nautical_mile\n", + "distance_f_descent = 3378.7*_units.nautical_mile\n", + "t_i_descent = 241. * _units.minute\n", + "t_f_descent = 299. * _units.minute\n", + "t_duration_descent = t_f_descent - t_i_descent\n", + "\n", + "##########################\n", + "# Design Variables #\n", + "##########################\n", + "\n", + "# Nudge it a bit off the correct answer to verify that the optimize takes us there.\n", + "aviary_inputs.set_val(av.Mission.Design.GROSS_MASS, 135000.0, units='lbm')\n", + "\n", + "prob.model.add_design_var(av.Mission.Design.GROSS_MASS, units='lbm',\n", + " lower=100000.0, upper=200000.0, ref=135000)\n", + "\n", + "##################\n", + "# Define Phases #\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.HeightEnergyPhaseBuilder(\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': (True, 'unitless'),\n", + " 'use_polynomial_control': (False, '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.HeightEnergyPhaseBuilder(\n", + " 'test_cruise',\n", + " user_options=av.AviaryValues({\n", + " 'initial_altitude': (alt_min_cruise, 'm'),\n", + " 'final_altitude': (alt_max_cruise, 'm'),\n", + " 'initial_mach': (cruise_mach, 'unitless'),\n", + " 'final_mach': (cruise_mach, 'unitless'),\n", + " 'required_available_climb_rate': (300, 'ft/min'),\n", + " 'fix_initial': (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.HeightEnergyPhaseBuilder(\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", + " 'use_polynomial_control': (False, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_descent,\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", + "# directly connect phases (strong_couple = True), or use linkage constraints (weak\n", + "# coupling / strong_couple=False)\n", + "strong_couple = 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", + "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(fix_initial=True, fix_duration=False, units='s',\n", + " duration_bounds=(t_duration_climb*0.5, t_duration_climb*2),\n", + " duration_ref=t_duration_climb)\n", + "cruise.set_time_options(fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(t_duration_cruise*0.5, t_duration_cruise*2),\n", + " duration_ref=t_duration_cruise,\n", + " initial_bounds=(t_duration_climb*0.5, t_duration_climb*2))\n", + "descent.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(t_duration_descent*0.5, t_duration_descent*2),\n", + " duration_ref=t_duration_descent,\n", + " initial_bounds=(\n", + " (t_duration_cruise + t_duration_climb)*0.5,\n", + " (t_duration_cruise + t_duration_climb)*2))\n", + "\n", + "traj.add_phase('climb', climb)\n", + "\n", + "traj.add_phase('cruise', cruise)\n", + "\n", + "traj.add_phase('descent', descent)\n", + "\n", + "traj.link_phases([\"climb\", \"cruise\", \"descent\"], [\n", + " \"time\", \"mass\", \"distance\"], connected=strong_couple)\n", + "\n", + "traj = av.setup_trajectory_params(prob.model, traj, aviary_inputs)\n", + "\n", + "##########################\n", + "# Constraints #\n", + "##########################\n", + "\n", + "ecomp = om.ExecComp('fuel_burned = initial_mass - descent_mass_final',\n", + " initial_mass={'units': 'lbm', 'shape': 1},\n", + " descent_mass_final={'units': 'lbm', 'shape': 1},\n", + " fuel_burned={'units': 'lbm', 'shape': 1})\n", + "\n", + "prob.model.add_subsystem('fuel_burn', ecomp,\n", + " promotes_inputs=[\n", + " ('initial_mass', av.Mission.Design.GROSS_MASS)],\n", + " promotes_outputs=['fuel_burned'])\n", + "\n", + "prob.model.connect(\"traj.descent.states:mass\",\n", + " \"fuel_burn.descent_mass_final\", src_indices=[-1])\n", + "\n", + "##########################\n", + "# Add Objective Function #\n", + "##########################\n", + "\n", + "prob.model.add_objective(\"fuel_burned\", ref=1e4)\n", + "\n", + "# Set initial default values for all LEAPS aircraft variables.\n", + "av.set_aviary_initial_values(prob.model, aviary_inputs)\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(force_alloc_complex=True)\n", + "\n", + "###########################################\n", + "# Initial 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.controls:altitude', climb.interp(\n", + " av.Dynamic.Mission.ALTITUDE, ys=[alt_i_climb, alt_f_climb]), units='m')\n", + "prob.set_val(\n", + " 'traj.climb.controls:mach', climb.interp(\n", + " av.Dynamic.Mission.MACH, ys=[mach_i_climb, mach_f_climb]), units='unitless')\n", + "prob.set_val('traj.climb.states:mass', climb.interp(\n", + " av.Dynamic.Mission.MASS, ys=[mass_i_climb, mass_f_climb]), units='kg')\n", + "prob.set_val('traj.climb.states:distance', climb.interp(\n", + " av.Dynamic.Mission.DISTANCE, ys=[distance_i_climb, distance_f_climb]), units='m')\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.polynomial_controls:altitude', cruise.interp(\n", + " av.Dynamic.Mission.ALTITUDE, ys=[alt_i_cruise, alt_f_cruise]), units='m')\n", + "prob.set_val(\n", + " 'traj.cruise.polynomial_controls:mach', cruise.interp(\n", + " av.Dynamic.Mission.MACH, ys=[cruise_mach, cruise_mach]), units='unitless')\n", + "prob.set_val('traj.cruise.states:mass', cruise.interp(\n", + " av.Dynamic.Mission.MASS, ys=[mass_i_cruise, mass_f_cruise]), units='kg')\n", + "prob.set_val('traj.cruise.states:distance', cruise.interp(\n", + " av.Dynamic.Mission.DISTANCE, ys=[distance_i_cruise, distance_f_cruise]), units='m')\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.controls:altitude', descent.interp(\n", + " av.Dynamic.Mission.ALTITUDE, ys=[alt_i_descent, alt_f_descent]), units='m')\n", + "prob.set_val(\n", + " 'traj.descent.controls:mach', descent.interp(\n", + " av.Dynamic.Mission.MACH, ys=[mach_i_descent, mach_f_descent]), units='unitless')\n", + "prob.set_val('traj.descent.states:mass', descent.interp(\n", + " av.Dynamic.Mission.MASS, ys=[mass_i_descent, mass_f_descent]), units='kg')\n", + "prob.set_val('traj.descent.states:distance', descent.interp(\n", + " av.Dynamic.Mission.DISTANCE, ys=[distance_i_descent, distance_f_descent]), units='m')\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})" + ] + } + ], + "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.10" + } + }, + "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..9cc44bc17 --- /dev/null +++ b/_sources/user_guide/external_aero.ipynb @@ -0,0 +1,280 @@ +{ + "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 unimportant 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", + "# Preprocess inputs\n", + "prob.check_and_preprocess_inputs()\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..de7b9a634 --- /dev/null +++ b/_sources/user_guide/features/overriding.ipynb @@ -0,0 +1,175 @@ +{ + "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", + "from aviary.validation_cases.validation_data.flops_data.FLOPS_Test_Data import FLOPS_Test_Data\n", + "\n", + "aviary_inputs = av.AviaryValues(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/hamilton_standard.md b/_sources/user_guide/hamilton_standard.md new file mode 100644 index 000000000..004b1d0cf --- /dev/null +++ b/_sources/user_guide/hamilton_standard.md @@ -0,0 +1,128 @@ +# Hamilton Standard Propulsion Model + +In the 1970s, NASA contracted Hamilton Standard to forecast into the future mid-80s to the 90s what they thought advanced propellers would look like. +The result is what we call “Hamilton Standard model” used in Aviary today. +The [Hamilton Standard Documentation is publicly available](https://ntrs.nasa.gov/api/citations/19720010354/downloads/19720010354.pdf). +You can find the definitions, methodology, and Fortran code in the document. +In Aviary, we implement only one of the computation options: the code computes the corresponding thrust for a given horsepower. + +Below is an XDSM diagram of Hamilton Standard model: + +![Hamilton Standard Diagram](images/hamilton_standard.png) + +The inputs are grouped in three aspects: + +Geometric inputs: + +- Propeller diameter +- Activity factor per blade (range: 80 to 200, baseline: 150) +- Number of blades (range: 2 to 8) + +Power inputs: + +- Shaft power to propeller (hp) +- Installation loss factor (0 to 1) + +Performance inputs: + +- Operating altitude (ft) +- True airspeed (knots) +- Propeller tip speed (Usually < 800 ft/s) +- Integrated lift coefficient (range: 0.3 to 0.8, baseline: 0.5) + +Some of the inputs are valid for limited ranges. +When using an odd number of blades, the Hamilton Standard model interpolates using the 2, 4, 6 and 8 blade data. +The corresponding outputs are: + +Geometric outputs: + +- Design blade pitch angle (at 0.75 Radius) + +Power outputs: + +- Installation loss factor +- Tip compressibility loss factor +- Power coefficient +- Thrust coefficient (rho=const, no losses) + +Performance outputs: + +- Flight Mach number +- Propeller tip Mach number +- Advance ratio +- Tip compressibility loss factor +- Thrust +- Propeller efficiency with compressibility losses +- Propeller efficiency with compressibility and installation losses + +As shown in the above XDSM diagram, the model is an OpenMDAO group that is composed of four components and one subgroup: + +- `USatmos` +- `PreHamiltonStandard` +- `HamiltonStandard` +- `InstallLoss` +- `PostHamiltonStandard` + +`USatmos` component provides the flight conditions. +The flight conditions are passed to the `PreHamiltonStandard` component which computes the propeller tip Mach number, advance ratio, and power coefficient. +These values are then fed into the `HamiltonStandard` component. + +`HamiltonStandard` is the core of the model. +Given the power coefficient (CP) and advance ratio (J), it finds the blade angle (BL) by a CP-BL chart by tracing the advance ratio. +Then with the blade angle, it finds the thrust coefficient (CT) using its CT-BL chart by tracing advance ratio again. +This algorithm is shown in the below pair of charts. +The CP → BL → CT chart matching algorithm is based on baseline data. +If the user-inputted values are not in the valid region, it will first convert them to those baseline parameters by a sequence of interpolations to do the necessary corrections. +The newly converted parameters are called “effective parameters” (e.g., CPE and CTE). +The outputs are blade angle, thrust coefficient and tip compressibility loss factor. + +![CP and CT matching](images/CPE_CTE_matching.png) + +Finally, the thrust is computed in the `PostHamiltonStandard` component based on thrust coefficient and tip compressibility loss factor. + +The Hamilton Standard model uses wind tunnel test data from uninstalled propellers. +When a nacelle is mounted behind the propeller, an installation loss factor is introduced. +The installation loss factor can be given by the user or computed. +If it is computed, we need another group of components as shown below: + +![Installation Loss Factor](images/installation_loss_factor.png) + +This diagram is represented by `InstallLoss` group in the first diagram. +Nacelle diameter is needed when installation loss factor is computed. +We use the average nacelle diameter. + +The newly added aviary options and variables are: + +```none +Aircraft.Engine.PROPELLER_DIAMETER +Aircraft.Engine.PROPELLER_INTEGRATED_LIFT_COEFFICIENT +Aircraft.Engine.PROPELLER_ACTIVITY_FACTOR +Aircraft.Engine.NUM_PROPELLER_BLADES +Aircraft.Design.COMPUTE_INSTALLATION_LOSS +Dynamic.Mission.PROPELLER_TIP_SPEED +Dynamic.Mission.SHAFT_POWER +Dynamic.Mission.INSTALLATION_LOSS_FACTOR +``` + +To build a turboprop engine that uses the Hamilton Standard propeller model we use a `TurboPropDeck` object with `prop_model` set to `True`: + +```python +engine = TurboPropDeck(options=options, prop_model=True) +``` + +Some inputs are options: + +```python +options.set_val(Aircraft.Engine.PROPELLER_DIAMETER, 10, units='ft') +options.set_val(Aircraft.Engine.NUM_PROPELLER_BLADES, val=4, units='unitless') +options.set_val(Aircraft.Design.COMPUTE_INSTALLATION_LOSS, val=True, units='unitless') +``` + +We set the inputs like the following: + +```python +prob.set_val(f'traj.cruise.rhs_all.{Aircraft.Design.MAX_PROPELLER_TIP_SPEED}', 710., units='ft/s') +prob.set_val(f'traj.cruise.rhs_all.{Dynamic.Mission.PERCENT_ROTOR_RPM_CORRECTED}', 0.915, units='unitless') +prob.set_val(f'traj.cruise.rhs_all.{Aircraft.Engine.PROPELLER_ACTIVITY_FACTOR}', 150., units='unitless') +prob.set_val(f'traj.cruise.rhs_all.{Aircraft.Engine.PROPELLER_INTEGRATED_LIFT_COEFFICIENT}', 0.5, units='unitless') +``` diff --git a/_sources/user_guide/input_files.ipynb b/_sources/user_guide/input_files.ipynb new file mode 100644 index 000000000..cf8a12fb5 --- /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 can use 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..e1805f067 --- /dev/null +++ b/_sources/user_guide/outputs_and_how_to_read_them.md @@ -0,0 +1,138 @@ +# 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 | Subsystem Results | ./reports/subsystems/*name_of_subsystem.md (or .html)* | +| Results | Mission Results | ./reports/subsystems/mission_summary.md | + +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). + +### Report Location + +Reports are placed a subdirectory called `reports` under the directory where the script was run. The subdirectory's name for Level 1 runs is based on the name of the CSV file used to define aircraft and mission properties. For Level 2 and Level 3 runs, the name is based on the name of the Python script being run. + +### Warning About the Reports Directory + +Repeated runs of the same script (Levels 2 and 3) or the same aircraft definition CSV file (Level 1) will overwrite existing reports directories. So to preserve reports from previous runs, the user should make copies of the report directory before starting another run. + +### 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). + +### Timeseries Mission Output Report + +The outputs of the aircraft trajectory are outputted in a file called `mission_timeseries_data.csv` within the reports directory. +This file contains a comma-separated list of some outputs from the mission. +Any value that is included in the timeseries data is included in this file. +These files are useful for post-processing and inputting the mission outputs into other tools, especially those used for acoustic analysis. + +```{note} +This feature is under further development. Please let us know if you have any suggestions for functionality or improvements. This feature is not currently supported when using the shooting integration method. +``` + +Here is an example of the first few lines of a `mission_timeseries_data.csv` file: + +```{code} +time (s),mach (unitless),thrust_net_total (lbf),drag (lbf),specific_energy_rate_excess (m/s),fuel_flow_rate_negative_total (lbm/h),altitude_rate (ft/s),throttle (unitless),velocity (m/s),time_phase (s),mach_rate (unitless/s),altitude (ft),mass (kg),distance (m) +0.0,0.2,28478.788920867584,21108.418300418845,12.350271989430475,-10492.593707324704,8.333333333333337,0.565484286063171,68.05737270077049,0.0,0.0001354166666666668,0.0,79560.101698,1.0 +160.16130859524844,0.22168851053893995,24443.964075954416,17707.343638310154,13.681656556939739,-9195.769418149232,8.333333333333341,0.5231597651569796,75.090771635822,160.16130859524844,0.0001354166666666669,1334.6775716270722,79362.06974727994,11458.09964519708 +``` + +If you want to add additional outputs, call `add_timeseries_output` on the phases. +Please refer to the [Dymos documentation on timeseries outputs](https://openmdao.org/dymos/docs/latest/features/phases/timeseries.html) for more information on how to do this. \ No newline at end of file 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..a4611cdeb --- /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/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/reserve_missions.md b/_sources/user_guide/reserve_missions.md new file mode 100644 index 000000000..9de726c5f --- /dev/null +++ b/_sources/user_guide/reserve_missions.md @@ -0,0 +1,81 @@ +# Reserve Mission + +## Overview + +Reserve missions are enabled for the following mission types: + +* height_energy (completed) +* 2ODF (collocation) (complete) +* 2DOF (shooting) (in-progress) +* height_energy (shooting) (future work) + +A reserve mission can be created by appending one or more reserve phases to `phase_info` after the last phase of the regular mission. +To create a simple reserve mission, copy your current cruise phase which is located in `phase_info`. + +```{note} +You may need to revise some of your assumptions for the copied phase if you are making a reserve phase that is radically different than the original (i.e. original phase was to travel 3000km but reserve phase is 100km). +``` + +Append that phase to the end of `phase_info`, name it `reserve_cruise` and add `"reserve": True,` to `user_options` for this phase. +There are two optional flags that can now be added to `user_options`. +The `"target_duration"` option creates a phase requiring the aircraft to fly for a specific amount of time. +The `"target_distance"` option creates a phase requiring the aircraft to fly for a specific distance. +Avoid using the optional flag if you have a reserve phase (i.e climb or descent) where you just want that phase to be completed as quickly as possible. +The optional flags should not be combined as they will create overlapping constraints creating an infeasible problem. + +You can chain together multiple reserve phases to make a complete reserve mission (i.e. climb to altitude, cruise for range, cruise for time, then descend). +Examples of this are shown in `run_reserve_mission_multiphase.py` and `run_2dof_reserve_mission_multiphase.py`. + +The first reserve phase will start at the same range and mass as the last regular phase, but all other states (i.e. altitude, Mach number) are not automatically connected. +Thus you can fly climb, cruise, descent for regular phases and then immediately jump to an arbitrary altitude for the reserve mission. +Or if you wanted to make things more realistic you could attach a climb phase and then add your reserve cruise. +Make sure both the reserve climb and the reserve cruise phases both have `"reserve": True,` flag. + +### Examples + +Examples of single-phase and multi-phase reserve missions are presented in [Reserve Mission Examples](../examples/reserve_missions.md). + +### Caveats when using 2DOF + +If you are using 2DOF equations of motion (EOM) in your problem (i.e. `settings:equations_of_motion,2DOF`) there are some additional things you need to be aware of. +The name of the reserve phase should include one of the keywords to indicate which EOM from 2DOF will be selected and the prefix `reserve_`. +Valid keywords include: `accel`, `ascent`, `climb1`, `climb2`, `cruise`, `desc1`, `desc2`. +This is because 2DOF uses different EOMs for different phases and we need to let `methods_for_level2.py` know which method to select. +This is why in the example in the first paragraph above, the phase was named `reserve_cruise`. +Cruise phases can have additional information in suffixes, but this isn't necessary. +Do not worry about phase naming if you are using Height-Energy EOM as all those EOMs are the same for every phase. + +## Theory + +When adding a reserve phase, `check_and_preprocess_inputs()` divides all the phases into two dictionaries: `regular_phases` which contain your nominal phases and `reserve_phases` which contains any phases with the `reserve` flag set to `True`. +Additionally, `check_and_preprocess_inputs()` will add the `"analytic"` flag to each phase. +This is used to indicate if a phase is an analytic phase (i.e. Breguet range) or a ordinary differential equation (ODE). + +Only the final mission mass and range from `regular_phases` are automatically connected to the first point of the `reserve_phases`. +All other state variables (i.e. altitude, mach) are not automatically connected, allowing you to start the reserve mission at whatever altitude you want. + +The `"analytic"` flag helps to properly connect phases for 2DOF missions. +2DOF `cruise` missions are analytic because they use a Breguet range calculation instead of integrating an EOM. +Analytic phases have a slightly different naming convention in order to access state/timeseries variables like distance, mass, and range compared with their non-analytic counterparts. + +You cannot create a reserve mission that enforces time or range constraints over multiple phases (i.e specify the total range covered by a climb + cruise + descent). +This is because each constraint `"target_distance"` or `"target_time"` is only enforced on a single phase. + +It is essential that you run `prob.check_and_preprocess_inputs()` after `prob.load_inputs()` to make sure that regular and reserve phases are separated via `phase_separator()`. + +### Advanced Users and Target Duration Phases + +For advanced users, instead of just copying a phase you used before, you might completely specify a new phase from scratch. +When creating a `"target_duration"` reserve phase there are a number of values inside of `phase_info['user_options']` that are overwritten in `check_and_preprocess_inputs()`. +Specifically, `duration_bounds`, `fixed_duration`, and `"initial_guesses": {"time"}` will be over-written. +That is because if `"target_duration"` is specified, Aviary already knows what these other three values need to be: `target_duration = duration_bounds = "initial_guesses": {"time"}`, and `fixed_duration = True`. + +### Fuel Burn Calculations + +Fuel burn during the regular mission (`Mission.Summary.FUEL_BURNED`) is calculated only based on `regular_phases`. + +Reserve fuel (`Mission.Design.RESERVE_FUEL`) is the sum of `Mission.Design.RESERVE_FUEL_ADDITIONAL`, `Mission.Design.RESERVE_FUEL_FRACTION`, and `Mission.Summary.RESERVE_FUEL_BURNED`. + +* `RESERVE_FUEL_ADDITIONAL` is a fixed value (i.e. 300kg) +* `RESERVE_FUEL_FRACTION` is based on a fraction of `Mission.Summary.FUEL_BURNED` +* `RESERVE_FUEL_BURNED` is sum of fuel burn in all `reserve_phases` 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..7556873d0 --- /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/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/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/Aviary/blob/main/aviary/external_subsystems/battery/battery_variable_meta_data.py) as well as the [core Aviary metadata](https://github.com/OpenMDAO/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/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/Aviary/blob/main/aviary/external_subsystems/battery/run_cruise.py) and [`run_multiphase_mission.py`](https://github.com/OpenMDAO/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/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..17a54be33 --- /dev/null +++ b/_sources/user_guide/troubleshooting.md @@ -0,0 +1,69 @@ +# 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 + +```{note} +A `VERBOSITY` control has been added to minimize the amount of unnecessary information that will be displayed. +Currently Quiet, Brief [default], Verbose, and Debug are supported. Quiet will suppress practically everything other than warnings and errors. Verbose will include information such as the progress of the optimization, instead of just a final summary. And Debug will contain detailed information about many of the steps as they happen. +Some of Aviary's CLI functions, such as `fortran_to_aviary`, allow the verbosity to be set directly with a command line argument. `run_mission` uses the variable `settings:verbosity` to control the print levels. +``` + +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..73b1052d3 --- /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 the [Variable Metadata doc page](../user_guide/variable_metadata.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.1e8bd061cd6da7fc9cf755528e8ffc24.min.css b/_sphinx_design_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css new file mode 100644 index 000000000..eb19f698a --- /dev/null +++ b/_sphinx_design_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.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: #0071bc;--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: #0060a0;--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..1c85bca0e --- /dev/null +++ b/_srcdocs/index.html @@ -0,0 +1,575 @@ + + + + + + + + + + + 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..8b7af1439 --- /dev/null +++ b/_srcdocs/packages/interface.html @@ -0,0 +1,570 @@ + + + + + + + + + + + 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..2c22ecb65 --- /dev/null +++ b/_srcdocs/packages/interface/cmd_entry_points.html @@ -0,0 +1,570 @@ + + + + + + + + + + + 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/download_models.html b/_srcdocs/packages/interface/download_models.html new file mode 100644 index 000000000..1b718ae2f --- /dev/null +++ b/_srcdocs/packages/interface/download_models.html @@ -0,0 +1,596 @@ + + + + + + + + + + + download_models.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+
+ + +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+ +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

download_models.py

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

download_models.py#

+
+
+
+aviary.interface.download_models.aviary_resource(resource_name: str) → str[source]
+
+ +
+
+aviary.interface.download_models.get_model(file_name: str, verbose=False) → Path[source]
+

This function attempts to find the path to a file or folder in aviary/models +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.

+
+
Returns:
+

The absolute path to the file.

+
+
Return type:
+

aviary_path

+
+
Raises:
+

FileNotFoundError – If the path is not found.

+
+
+
+ +
+
+aviary.interface.download_models.save_file(aviary_path: Path, outdir: Path, verbose=False) → Path[source]
+

Saves the file or folder specified into the output directory, creating directories as needed.

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

+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..830e0e337 --- /dev/null +++ b/_srcdocs/packages/interface/graphical_input.html @@ -0,0 +1,706 @@ + + + + + + + + + + + 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..189903528 --- /dev/null +++ b/_srcdocs/packages/interface/methods_for_level1.html @@ -0,0 +1,610 @@ + + + + + + + + + + + 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, verbosity=Verbosity.BRIEF)[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..e7e5c18cc --- /dev/null +++ b/_srcdocs/packages/interface/methods_for_level2.html @@ -0,0 +1,874 @@ + + + + + + + + + + + methods_for_level2.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+
+ + +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+ +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

methods_for_level2.py

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

methods_for_level2.py#

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

Bases: Group

+

A standard OpenMDAO group that handles Aviary’s promotions in the configure +method. This assures that we only call set_input_defaults on variables +that are present in the model.

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

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

Perform any one-time initialization run at instantiation.

+
+ +
+ +
+
+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, verbosity=Verbosity.BRIEF)[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.

    • +

  • verbosity (Verbosity or list, optional) – If Verbosity.DEBUG, 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(aviary_inputs, phase_info=None, engine_builder=None, verbosity=Verbosity.BRIEF)[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.

+
+ +
+
+phase_separator()[source]
+

This method checks for reserve=True & False +Returns an error if a non-reserve phase is specified after a reserve phase. +return two dictionaries of phases: regular_phases and reserve_phases

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

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

+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..762a4163b --- /dev/null +++ b/_srcdocs/packages/interface/reports.html @@ -0,0 +1,615 @@ + + + + + + + + + + + reports.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+
+ + +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+ +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

reports.py

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

reports.py#

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

Creates a basic mission summary report that is placed in the “reports” folder

+
+
Parameters:
+

prob (AviaryProblem) – The AviaryProblem used to generate this report

+
+
+
+ +
+
+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 used to generate this report

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

Generates a CSV file containing timeseries data for variables from an Aviary mission.

+

This function extracts timeseries data from the provided problem object, processes the data +to unify units across different phases of the mission, and then outputs the result to a CSV file. +The ‘time’ variable is moved to the beginning of the dataset so it’s always the leftmost column. +Duplicate consecutive rows are eliminated.

+
+
Parameters:
+
    +

  • prob (AviaryProblem) – The AviaryProblem used to generate this report

    • +

  • kwargs (dict) – Additional keyword arguments (unused)

    • +

  • directory. (The output CSV file is named 'mission_timeseries_data.csv' and is saved in the reports)

    • +

  • units. (The first row of the CSV file contains headers with variable names and)

    • +

  • step. (Each subsequent row represents the mission outputs at a different time)

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

+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..d7d1abc23 --- /dev/null +++ b/_srcdocs/packages/utils.html @@ -0,0 +1,581 @@ + + + + + + + + + + + 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/aero_table_conversion.html b/_srcdocs/packages/utils/aero_table_conversion.html new file mode 100644 index 000000000..9eb5b6e93 --- /dev/null +++ b/_srcdocs/packages/utils/aero_table_conversion.html @@ -0,0 +1,585 @@ + + + + + + + + + + + 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=<not given>, *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..d287d7d4c --- /dev/null +++ b/_srcdocs/packages/utils/aviary_values.html @@ -0,0 +1,606 @@ + + + + + + + + + + + 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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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..7fd4b639b --- /dev/null +++ b/_srcdocs/packages/utils/compare_hierarchies.html @@ -0,0 +1,658 @@ + + + + + + + + + + + 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..e0bba75d9 --- /dev/null +++ b/_srcdocs/packages/utils/conflict_checks.html @@ -0,0 +1,569 @@ + + + + + + + + + + + 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..473e8fe16 --- /dev/null +++ b/_srcdocs/packages/utils/csv_data_file.html @@ -0,0 +1,616 @@ + + + + + + + + + + + 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..75efdfa60 --- /dev/null +++ b/_srcdocs/packages/utils/data_interpolator_builder.html @@ -0,0 +1,602 @@ + + + + + + + + + + + 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..75bac3201 --- /dev/null +++ b/_srcdocs/packages/utils/develop_metadata.html @@ -0,0 +1,678 @@ + + + + + + + + + + + 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..5c8f95b78 --- /dev/null +++ b/_srcdocs/packages/utils/engine_deck_conversion.html @@ -0,0 +1,688 @@ + + + + + + + + + + + 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, output_file, data_format: EngineDeckType)[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)

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

Bases: Enum

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

+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..01ff08732 --- /dev/null +++ b/_srcdocs/packages/utils/fortran_to_aviary.html @@ -0,0 +1,650 @@ + + + + + + + + + + + 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

+
+
+aviary.utils.fortran_to_aviary.create_aviary_deck(fortran_deck: str, legacy_code=None, defaults_deck=None, out_file=None, force=False, verbosity=Verbosity.BRIEF)[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, verbosity=Verbosity.BRIEF)[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/functions.html b/_srcdocs/packages/utils/functions.html new file mode 100644 index 000000000..168d7e585 --- /dev/null +++ b/_srcdocs/packages/utils/functions.html @@ -0,0 +1,739 @@ + + + + + + + + + + + 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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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]
+
+ +
+
+aviary.utils.functions.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/utils/merge_hierarchies.html b/_srcdocs/packages/utils/merge_hierarchies.html new file mode 100644 index 000000000..44d00fba9 --- /dev/null +++ b/_srcdocs/packages/utils/merge_hierarchies.html @@ -0,0 +1,684 @@ + + + + + + + + + + + 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..c4eff019c --- /dev/null +++ b/_srcdocs/packages/utils/merge_variable_metadata.html @@ -0,0 +1,618 @@ + + + + + + + + + + + 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..e717e04f6 --- /dev/null +++ b/_srcdocs/packages/utils/named_values.html @@ -0,0 +1,774 @@ + + + + + + + + + + + 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)) → 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..c711ea020 --- /dev/null +++ b/_srcdocs/packages/utils/options.html @@ -0,0 +1,582 @@ + + + + + + + + + + + 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..d76ca0cbe --- /dev/null +++ b/_srcdocs/packages/utils/preprocessors.html @@ -0,0 +1,607 @@ + + + + + + + + + + + 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..9268cfbd8 --- /dev/null +++ b/_srcdocs/packages/utils/process_input_decks.html @@ -0,0 +1,674 @@ + + + + + + + + + + + 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='', verbosity=Verbosity.BRIEF)[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: {}, initial_guesses)[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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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_GASP_options(aircraft_values: {})[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)

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

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

+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..ce01697a5 --- /dev/null +++ b/_srcdocs/packages/utils/set_mass_defaults.html @@ -0,0 +1,569 @@ + + + + + + + + + + + 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..983d9dc4f --- /dev/null +++ b/_srcdocs/packages/variable_info.html @@ -0,0 +1,571 @@ + + + + + + + + + + + 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..381ad746c --- /dev/null +++ b/_srcdocs/packages/variable_info/core_promotes.html @@ -0,0 +1,565 @@ + + + + + + + + + + + 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..b2b55b906 --- /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=<not given>, *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=<not given>, *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=<not given>, *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'
+
+ +
+
+SOLVED_2DOF = 'solved_2DOF'
+
+ +
+
+TWO_DEGREES_OF_FREEDOM = '2DOF'
+
+ +
+ +
+
+class aviary.variable_info.enums.FlapType(value, names=<not given>, *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=<not given>, *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=<not given>, *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=<not given>, *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=<not given>, *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=<not given>, *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..820f90ce4 --- /dev/null +++ b/_srcdocs/packages/variable_info/functions.html @@ -0,0 +1,618 @@ + + + + + + + + + + + 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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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..1def43fba --- /dev/null +++ b/_srcdocs/packages/variable_info/options.html @@ -0,0 +1,594 @@ + + + + + + + + + + + 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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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_coefficient': {'default_value': 1.0, 'desc': 'mass trend coefficient of air conditioning', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(6)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(7)', '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': 'INGASP.CW(1)', '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': 'INGASP.CW(5)', '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:catering_items_mass_per_passenger': {'default_value': 0.7, 'desc': 'mass of catering items per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(12)', 'LEAPS1': None}, '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_per_passenger': {'default_value': 2.0, 'desc': 'mass of passenger service items mass per passenger', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(9)', 'LEAPS1': None}, '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:water_mass_per_occupant': {'default_value': 1.0, 'desc': 'mass of water per occupant (passengers, pilots, and flight attendants)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(10)', '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_installation_loss': {'default_value': True, 'desc': 'if true, compute installation loss factor based on blockage factor', '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:emergency_equipment_mass': {'default_value': 0.0, 'desc': 'mass of emergency equipment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(11)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, '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: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: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_propeller_tip_speed': {'default_value': 800.0, 'desc': 'maximum allowable propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TSPDMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, '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:reserve_fuel_additional': {'default_value': 0, 'desc': 'required fuel reserves: directly in lbm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:design:reserve_fuel_fraction': {'default_value': 0, 'desc': 'required fuel reserves: given as a proportion of mission fuel. This value must be nonnegative. Mission fuel only includes normal phases and excludes reserve phases. If it is 0.5, the reserve fuel is half of the mission fuel (one third of the total fuel). Note it can be greater than 1. If it is 2, there would be twice as much reserve fuel as mission fuel (the total fuel carried would be 1/3 for the mission and 2/3 for the reserve)', 'historical_name': {'FLOPS': None, 'GASP': None, '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_propeller_blades': {'default_value': 0, 'desc': 'number of blades per propeller', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BL', 'LEAPS1': None}, '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:propeller_activity_factor': {'default_value': 0.0, 'desc': 'propeller actitivty factor per Blade (Range: 80 to 200)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:propeller_diameter': {'default_value': 0.0, 'desc': 'propeller diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DPROP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:propeller_integrated_lift_coefficient': {'default_value': 0.5, 'desc': 'propeller blade integrated design lift coefficient (Range: 0.3 to 0.8)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLI', '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_coefficient': {'default_value': 6.0, 'desc': 'mass trend coefficient of trapped fuel factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(13)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'INGASP.CW(8)', '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:flight_control_mass_coefficient': {'default_value': 0.1, 'desc': 'mass trend coefficient of hydraulics for flight control system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(3)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:gear_mass_coefficient': {'default_value': 0.16, 'desc': 'mass trend coefficient of hydraulics for landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(4)', 'LEAPS1': None}, '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_coefficient': {'default_value': 0.0862, 'desc': 'mass trend coefficient of instruments', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW(2)', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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': 'range', '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': 'range_rate', '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'}, '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'}, 'installation_loss_factor': {'default_value': 0.0, 'desc': 'fraction of total propeller thrust which is lost due to installation', 'historical_name': {'FLOPS': None, 'GASP': 'FT', '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'}, 'mach_rate': {'default_value': 0.0, 'desc': 'Current rate at which the Mach number of the vehicle is changing', '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:constraints:range_residual_reserve': {'default_value': 0.0, 'desc': 'residual to make sure aircraft reserve mission 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 which is the sum of: RESERVE_FUEL_BURNED, RESERVE_FUEL_ADDITIONAL, RESERVE_FUEL_FRACTION', '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 groundroll portion 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 only required to be equal to Aircraft.Design.TOUCHDOWN_MASS when the design case is being run for HEIGHT_ENERGY missions this is the mass at the end of the last regular phase (non-reserve phase)', '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_burned': {'default_value': 0.0, 'desc': 'fuel burned during regular phases, this does not include fuel burned in reserve phases', '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, not necessarily 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, whether it is a design case or an off design case. Equal to Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:reserve_fuel_burned': {'default_value': 0.0, 'desc': 'fuel burned during reserve phases, this does not include fuel burned in regular phases', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a mission includes fuel burned in the mission, reserve fuel and 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_mach': {'default_value': 0.0, 'desc': 'Mach number of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, '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 groundroll portion 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'}, 'percent_rotor_rpm_corrected': {'default_value': 0.9, 'desc': 'percent of the corrected rotor speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'propeller_tip_speed': {'default_value': 500.0, 'desc': 'propeller tip speed', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/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 information 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'}, 'shaft_power': {'default_value': 0.0, 'desc': 'The shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'shaft_power_corrected': {'default_value': 0.0, 'desc': 'The corrected shaft horsepower', 'historical_name': {'FLOPS': None, 'GASP': 'SHPCOR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'hp'}, 'specific_energy': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (energy per unit weight) 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': {'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..8bf45a365 --- /dev/null +++ b/_srcdocs/packages/variable_info/variable_meta_data.html @@ -0,0 +1,565 @@ + + + + + + + + + + + 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..3db94b4c2 --- /dev/null +++ b/_srcdocs/packages/variable_info/variables.html @@ -0,0 +1,3544 @@ + + + + + + + + + + + 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_COEFFICIENT = 'aircraft:air_conditioning:mass_coefficient'
+
+ +
+
+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'
+
+ +
+
+CATERING_ITEMS_MASS_PER_PASSENGER = 'aircraft:crew_and_payload:catering_items_mass_per_passenger'
+
+ +
+
+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_PER_PASSENGER = 'aircraft:crew_and_payload:passenger_service_mass_per_passenger'
+
+ +
+
+PASSENGER_SERVICE_MASS_SCALER = 'aircraft:crew_and_payload:passenger_service_mass_scaler'
+
+ +
+
+TOTAL_PAYLOAD_MASS = 'aircraft:crew_and_payload:total_payload_mass'
+
+ +
+
+WATER_MASS_PER_OCCUPANT = 'aircraft:crew_and_payload:water_mass_per_occupant'
+
+ +
+
+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_INSTALLATION_LOSS = 'aircraft:design:compute_installation_loss'
+
+ +
+
+COMPUTE_VTAIL_VOLUME_COEFF = 'aircraft:design:compute_vtail_volume_coeff'
+
+ +
+
+DRAG_COEFFICIENT_INCREMENT = 'aircraft:design:drag_increment'
+
+ +
+
+DRAG_POLAR = 'aircraft:design:drag_polar'
+
+ +
+
+EMERGENCY_EQUIPMENT_MASS = 'aircraft:design:emergency_equipment_mass'
+
+ +
+
+EMPTY_MASS = 'aircraft:design:empty_mass'
+
+ +
+
+EMPTY_MASS_MARGIN = 'aircraft:design:empty_mass_margin'
+
+ +
+
+EMPTY_MASS_MARGIN_SCALER = 'aircraft:design:empty_mass_margin_scaler'
+
+ +
+
+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 = '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_PROPELLER_TIP_SPEED = 'aircraft:design:max_propeller_tip_speed'
+
+ +
+
+MAX_STRUCTURAL_SPEED = 'aircraft:design:max_structural_speed'
+
+ +
+
+OPERATING_MASS = 'aircraft:design:operating_mass'
+
+ +
+
+PART25_STRUCTURAL_CATEGORY = 'aircraft:design:part25_structural_category'
+
+ +
+
+RESERVE_FUEL_ADDITIONAL = 'aircraft:design:reserve_fuel_additional'
+
+ +
+
+RESERVE_FUEL_FRACTION = 'aircraft:design:reserve_fuel_fraction'
+
+ +
+
+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'
+
+ +
+
+NUM_ENGINES = 'aircraft:engine:num_engines'
+
+ +
+
+NUM_FUSELAGE_ENGINES = 'aircraft:engine:num_fuselage_engines'
+
+ +
+
+NUM_PROPELLER_BLADES = 'aircraft:engine:num_propeller_blades'
+
+ +
+
+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'
+
+ +
+
+PROPELLER_ACTIVITY_FACTOR = 'aircraft:engine:propeller_activity_factor'
+
+ +
+
+PROPELLER_DIAMETER = 'aircraft:engine:propeller_diameter'
+
+ +
+
+PROPELLER_INTEGRATED_LIFT_COEFFICIENT = 'aircraft:engine:propeller_integrated_lift_coefficient'
+
+ +
+
+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_COEFFICIENT = 'aircraft:fuel:unusable_fuel_mass_coefficient'
+
+ +
+
+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

+
+
+FLIGHT_CONTROL_MASS_COEFFICIENT = 'aircraft:hydraulics:flight_control_mass_coefficient'
+
+ +
+
+GEAR_MASS_COEFFICIENT = 'aircraft:hydraulics:gear_mass_coefficient'
+
+ +
+
+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_COEFFICIENT = 'aircraft:instruments:mass_coefficient'
+
+ +
+
+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_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'
+
+ +
+
+INSTALLATION_LOSS_FACTOR = 'installation_loss_factor'
+
+ +
+
+LIFT = 'lift'
+
+ +
+
+MACH = 'mach'
+
+ +
+
+MACH_RATE = 'mach_rate'
+
+ +
+
+MASS = 'mass'
+
+ +
+
+MASS_RATE = 'mass_rate'
+
+ +
+
+NOX_RATE = 'nox_rate'
+
+ +
+
+NOX_RATE_TOTAL = 'nox_rate_total'
+
+ +
+
+PERCENT_ROTOR_RPM_CORRECTED = 'percent_rotor_rpm_corrected'
+
+ +
+
+PROPELLER_TIP_SPEED = 'propeller_tip_speed'
+
+ +
+
+SHAFT_POWER = 'shaft_power'
+
+ +
+
+SHAFT_POWER_CORRECTED = 'shaft_power_corrected'
+
+ +
+
+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'
+
+ +
+
+RANGE_RESIDUAL_RESERVE = 'mission:constraints:range_residual_reserve'
+
+ +
+ +
+
+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_BURNED = 'mission:summary:fuel_burned'
+
+ +
+
+FUEL_FLOW_SCALER = 'mission:summary:fuel_flow_scaler'
+
+ +
+
+GROSS_MASS = 'mission:summary:gross_mass'
+
+ +
+
+RANGE = 'mission:summary:range'
+
+ +
+
+RESERVE_FUEL_BURNED = 'mission:summary:reserve_fuel_burned'
+
+ +
+
+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_MACH = 'mission:takeoff:final_mach'
+
+ +
+
+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..e298cff7b --- /dev/null +++ b/_srcdocs/packages/variable_info/variables_in.html @@ -0,0 +1,593 @@ + + + + + + + + + + + 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/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..2af6139e6 --- /dev/null +++ b/_static/basic.css @@ -0,0 +1,925 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2024 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; +} + +a:visited { + color: #551A8B; +} + +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; +} + +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; +} + +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 > 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; +} + +.sig dd { + margin-top: 0px; + margin-bottom: 0px; +} + +.sig dl { + margin-top: 0px; + margin-bottom: 0px; +} + +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; +} + +.translated { + background-color: rgba(207, 255, 207, 0.2) +} + +.untranslated { + background-color: rgba(255, 207, 207, 0.2) +} + +/* -- 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.1e8bd061cd6da7fc9cf755528e8ffc24.min.css b/_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css new file mode 100644 index 000000000..eb19f698a --- /dev/null +++ b/_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.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: #0071bc;--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: #0060a0;--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..4d67807d1 --- /dev/null +++ b/_static/doctools.js @@ -0,0 +1,156 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Base JavaScript utilities for all Sphinx HTML documentation. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([ + "TEXTAREA", + "INPUT", + "SELECT", + "BUTTON", +]); + +const _ready = (callback) => { + if (document.readyState !== "loading") { + callback(); + } else { + document.addEventListener("DOMContentLoaded", callback); + } +}; + +/** + * Small JavaScript module for the documentation. + */ +const Documentation = { + init: () => { + 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; + }, + + /** + * 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; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.altKey || event.ctrlKey || event.metaKey) return; + + 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; + } + } + + // 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..dab586c0d --- /dev/null +++ b/_static/documentation_options.js @@ -0,0 +1,13 @@ +const DOCUMENTATION_OPTIONS = { + 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: true, +}; \ 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/language_data.js b/_static/language_data.js new file mode 100644 index 000000000..367b8ed81 --- /dev/null +++ b/_static/language_data.js @@ -0,0 +1,199 @@ +/* + * language_data.js + * ~~~~~~~~~~~~~~~~ + * + * This script contains the language-specific data used by searchtools.js, + * namely the list of stopwords, stemmer, scorer and splitter. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +var stopwords = ["a", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "near", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"]; + + +/* Non-minified version is copied as a separate JS file, if available */ + +/** + * Porter Stemmer + */ +var Stemmer = function() { + + var step2list = { + ational: 'ate', + tional: 'tion', + enci: 'ence', + anci: 'ance', + izer: 'ize', + bli: 'ble', + alli: 'al', + entli: 'ent', + eli: 'e', + ousli: 'ous', + ization: 'ize', + ation: 'ate', + ator: 'ate', + alism: 'al', + iveness: 'ive', + fulness: 'ful', + ousness: 'ous', + aliti: 'al', + iviti: 'ive', + biliti: 'ble', + logi: 'log' + }; + + var step3list = { + icate: 'ic', + ative: '', + alize: 'al', + iciti: 'ic', + ical: 'ic', + ful: '', + ness: '' + }; + + var c = "[^aeiou]"; // consonant + var v = "[aeiouy]"; // vowel + var C = c + "[^aeiouy]*"; // consonant sequence + var V = v + "[aeiou]*"; // vowel sequence + + var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0 + var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1 + var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1 + var s_v = "^(" + C + ")?" + v; // vowel in stem + + this.stemWord = function (w) { + var stem; + var suffix; + var firstch; + var origword = w; + + if (w.length < 3) + return w; + + var re; + var re2; + var re3; + var re4; + + firstch = w.substr(0,1); + if (firstch == "y") + w = firstch.toUpperCase() + w.substr(1); + + // Step 1a + re = /^(.+?)(ss|i)es$/; + re2 = /^(.+?)([^s])s$/; + + if (re.test(w)) + w = w.replace(re,"$1$2"); + else if (re2.test(w)) + w = w.replace(re2,"$1$2"); + + // Step 1b + re = /^(.+?)eed$/; + re2 = /^(.+?)(ed|ing)$/; + if (re.test(w)) { + var fp = re.exec(w); + re = new RegExp(mgr0); + if (re.test(fp[1])) { + re = /.$/; + w = w.replace(re,""); + } + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1]; + re2 = new RegExp(s_v); + if (re2.test(stem)) { + w = stem; + re2 = /(at|bl|iz)$/; + re3 = new RegExp("([^aeiouylsz])\\1$"); + re4 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re2.test(w)) + w = w + "e"; + else if (re3.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + else if (re4.test(w)) + w = w + "e"; + } + } + + // Step 1c + re = /^(.+?)y$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(s_v); + if (re.test(stem)) + w = stem + "i"; + } + + // Step 2 + re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step2list[suffix]; + } + + // Step 3 + re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step3list[suffix]; + } + + // Step 4 + re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; + re2 = /^(.+?)(s|t)(ion)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + if (re.test(stem)) + w = stem; + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1] + fp[2]; + re2 = new RegExp(mgr1); + if (re2.test(stem)) + w = stem; + } + + // Step 5 + re = /^(.+?)e$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + re2 = new RegExp(meq1); + re3 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) + w = stem; + } + re = /ll$/; + re2 = new RegExp(mgr1); + if (re.test(w) && re2.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + + // and turn initial Y back to y + if (firstch == "y") + w = firstch.toLowerCase() + w.substr(1); + return w; + } +} + diff --git a/_static/locales/ar/LC_MESSAGES/booktheme.mo b/_static/locales/ar/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..15541a6a3 Binary files /dev/null and b/_static/locales/ar/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ar/LC_MESSAGES/booktheme.po b/_static/locales/ar/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..1237f3432 --- /dev/null +++ b/_static/locales/ar/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ar\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "تنزيل ملف المصدر" + +msgid "suggest edit" +msgstr "أقترح تحرير" + +msgid "Toggle navigation" +msgstr "تبديل التنقل" + +msgid "open issue" +msgstr "قضية مفتوحة" + +msgid "Download notebook file" +msgstr "تنزيل ملف دفتر الملاحظات" + +msgid "repository" +msgstr "مخزن" + +msgid "Theme by the" +msgstr "موضوع بواسطة" + +msgid "Print to PDF" +msgstr "طباعة إلى PDF" + +msgid "Download this page" +msgstr "قم بتنزيل هذه الصفحة" + +msgid "Copyright" +msgstr "حقوق النشر" + +msgid "Last updated on" +msgstr "آخر تحديث في" + +msgid "Launch" +msgstr "إطلاق" + +msgid "Open an issue" +msgstr "افتح قضية" + +msgid "Fullscreen mode" +msgstr "وضع ملء الشاشة" + +msgid "Sphinx Book Theme" +msgstr "موضوع كتاب أبو الهول" + +msgid "Contents" +msgstr "محتويات" + +msgid "Edit this page" +msgstr "قم بتحرير هذه الصفحة" + +msgid "next page" +msgstr "الصفحة التالية" + +msgid "Source repository" +msgstr "مستودع المصدر" + +msgid "By" +msgstr "بواسطة" + +msgid "By the" +msgstr "بواسطة" + +msgid "previous page" +msgstr "الصفحة السابقة" diff --git a/_static/locales/bg/LC_MESSAGES/booktheme.mo b/_static/locales/bg/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..da9512003 Binary files /dev/null and b/_static/locales/bg/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/bg/LC_MESSAGES/booktheme.po b/_static/locales/bg/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..45a6ed0a4 --- /dev/null +++ b/_static/locales/bg/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: bg\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Изтеглете изходния файл" + +msgid "suggest edit" +msgstr "предложи редактиране" + +msgid "Toggle navigation" +msgstr "Превключване на навигацията" + +msgid "open issue" +msgstr "отворен брой" + +msgid "Download notebook file" +msgstr "Изтеглете файла на бележника" + +msgid "repository" +msgstr "хранилище" + +msgid "Theme by the" +msgstr "Тема от" + +msgid "Print to PDF" +msgstr "Печат в PDF" + +msgid "Download this page" +msgstr "Изтеглете тази страница" + +msgid "Copyright" +msgstr "Авторско право" + +msgid "Last updated on" +msgstr "Последна актуализация на" + +msgid "Launch" +msgstr "Стартиране" + +msgid "Open an issue" +msgstr "Отворете проблем" + +msgid "Fullscreen mode" +msgstr "Режим на цял екран" + +msgid "Sphinx Book Theme" +msgstr "Тема на книгата Sphinx" + +msgid "Contents" +msgstr "Съдържание" + +msgid "Edit this page" +msgstr "Редактирайте тази страница" + +msgid "next page" +msgstr "Следваща страница" + +msgid "Source repository" +msgstr "Хранилище на източника" + +msgid "By" +msgstr "От" + +msgid "By the" +msgstr "По" + +msgid "previous page" +msgstr "предишна страница" diff --git a/_static/locales/bn/LC_MESSAGES/booktheme.mo b/_static/locales/bn/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..6b96639b7 Binary files /dev/null and b/_static/locales/bn/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/bn/LC_MESSAGES/booktheme.po b/_static/locales/bn/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..122a369e5 --- /dev/null +++ b/_static/locales/bn/LC_MESSAGES/booktheme.po @@ -0,0 +1,63 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: bn\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "উত্স ফাইল ডাউনলোড করুন" + +msgid "Toggle navigation" +msgstr "নেভিগেশন টগল করুন" + +msgid "open issue" +msgstr "খোলা সমস্যা" + +msgid "Download notebook file" +msgstr "নোটবুক ফাইল ডাউনলোড করুন" + +msgid "Theme by the" +msgstr "থিম দ্বারা" + +msgid "Print to PDF" +msgstr "পিডিএফ প্রিন্ট করুন" + +msgid "Download this page" +msgstr "এই পৃষ্ঠাটি ডাউনলোড করুন" + +msgid "Copyright" +msgstr "কপিরাইট" + +msgid "Last updated on" +msgstr "সর্বশেষ আপডেট" + +msgid "Launch" +msgstr "শুরু করা" + +msgid "Open an issue" +msgstr "একটি সমস্যা খুলুন" + +msgid "Sphinx Book Theme" +msgstr "স্পিনিক্স বুক থিম" + +msgid "Edit this page" +msgstr "এই পৃষ্ঠাটি সম্পাদনা করুন" + +msgid "next page" +msgstr "পরবর্তী পৃষ্ঠা" + +msgid "Source repository" +msgstr "উত্স সংগ্রহস্থল" + +msgid "By" +msgstr "দ্বারা" + +msgid "By the" +msgstr "দ্বারা" + +msgid "previous page" +msgstr "আগের পৃষ্ঠা" diff --git a/_static/locales/ca/LC_MESSAGES/booktheme.mo b/_static/locales/ca/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..a4dd30e9b Binary files /dev/null and b/_static/locales/ca/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ca/LC_MESSAGES/booktheme.po b/_static/locales/ca/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..c757deb8e --- /dev/null +++ b/_static/locales/ca/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ca\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Baixeu el fitxer font" + +msgid "suggest edit" +msgstr "suggerir edició" + +msgid "Toggle navigation" +msgstr "Commuta la navegació" + +msgid "open issue" +msgstr "número obert" + +msgid "Download notebook file" +msgstr "Descarregar fitxer de quadern" + +msgid "Theme by the" +msgstr "Tema del" + +msgid "Print to PDF" +msgstr "Imprimeix a PDF" + +msgid "Download this page" +msgstr "Descarregueu aquesta pàgina" + +msgid "Copyright" +msgstr "Copyright" + +msgid "Last updated on" +msgstr "Darrera actualització el" + +msgid "Launch" +msgstr "Llançament" + +msgid "Open an issue" +msgstr "Obriu un número" + +msgid "Sphinx Book Theme" +msgstr "Tema del llibre Esfinx" + +msgid "Edit this page" +msgstr "Editeu aquesta pàgina" + +msgid "next page" +msgstr "pàgina següent" + +msgid "Source repository" +msgstr "Dipòsit de fonts" + +msgid "By" +msgstr "Per" + +msgid "By the" +msgstr "Per la" + +msgid "previous page" +msgstr "Pàgina anterior" diff --git a/_static/locales/cs/LC_MESSAGES/booktheme.mo b/_static/locales/cs/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..c39e01a6a Binary files /dev/null and b/_static/locales/cs/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/cs/LC_MESSAGES/booktheme.po b/_static/locales/cs/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..3571c23b4 --- /dev/null +++ b/_static/locales/cs/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: cs\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Stáhněte si zdrojový soubor" + +msgid "suggest edit" +msgstr "navrhnout úpravy" + +msgid "Toggle navigation" +msgstr "Přepnout navigaci" + +msgid "open issue" +msgstr "otevřené číslo" + +msgid "Download notebook file" +msgstr "Stáhnout soubor poznámkového bloku" + +msgid "repository" +msgstr "úložiště" + +msgid "Theme by the" +msgstr "Téma od" + +msgid "Print to PDF" +msgstr "Tisk do PDF" + +msgid "Download this page" +msgstr "Stáhněte si tuto stránku" + +msgid "Copyright" +msgstr "autorská práva" + +msgid "Last updated on" +msgstr "Naposledy aktualizováno" + +msgid "Launch" +msgstr "Zahájení" + +msgid "Open an issue" +msgstr "Otevřete problém" + +msgid "Fullscreen mode" +msgstr "Režim celé obrazovky" + +msgid "Sphinx Book Theme" +msgstr "Téma knihy Sfinga" + +msgid "Contents" +msgstr "Obsah" + +msgid "Edit this page" +msgstr "Upravit tuto stránku" + +msgid "next page" +msgstr "další strana" + +msgid "Source repository" +msgstr "Zdrojové úložiště" + +msgid "By" +msgstr "Podle" + +msgid "By the" +msgstr "Podle" + +msgid "previous page" +msgstr "předchozí stránka" diff --git a/_static/locales/da/LC_MESSAGES/booktheme.mo b/_static/locales/da/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..f43157d70 Binary files /dev/null and b/_static/locales/da/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/da/LC_MESSAGES/booktheme.po b/_static/locales/da/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..c39223fde --- /dev/null +++ b/_static/locales/da/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: da\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Download kildefil" + +msgid "suggest edit" +msgstr "foreslå redigering" + +msgid "Toggle navigation" +msgstr "Skift navigation" + +msgid "open issue" +msgstr "åbent nummer" + +msgid "Download notebook file" +msgstr "Download notesbog-fil" + +msgid "repository" +msgstr "lager" + +msgid "Theme by the" +msgstr "Tema af" + +msgid "Print to PDF" +msgstr "Udskriv til PDF" + +msgid "Download this page" +msgstr "Download denne side" + +msgid "Copyright" +msgstr "ophavsret" + +msgid "Last updated on" +msgstr "Sidst opdateret den" + +msgid "Launch" +msgstr "Start" + +msgid "Open an issue" +msgstr "Åbn et problem" + +msgid "Fullscreen mode" +msgstr "Fuldskærmstilstand" + +msgid "Sphinx Book Theme" +msgstr "Sphinx bogtema" + +msgid "Contents" +msgstr "Indhold" + +msgid "Edit this page" +msgstr "Rediger denne side" + +msgid "next page" +msgstr "Næste side" + +msgid "Source repository" +msgstr "Kildelager" + +msgid "By" +msgstr "Ved" + +msgid "By the" +msgstr "Ved" + +msgid "previous page" +msgstr "forrige side" diff --git a/_static/locales/de/LC_MESSAGES/booktheme.mo b/_static/locales/de/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..648b565c7 Binary files /dev/null and b/_static/locales/de/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/de/LC_MESSAGES/booktheme.po b/_static/locales/de/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..e22b505f2 --- /dev/null +++ b/_static/locales/de/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: de\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Quelldatei herunterladen" + +msgid "suggest edit" +msgstr "vorschlagen zu bearbeiten" + +msgid "Toggle navigation" +msgstr "Navigation umschalten" + +msgid "open issue" +msgstr "offenes Thema" + +msgid "Download notebook file" +msgstr "Notebook-Datei herunterladen" + +msgid "repository" +msgstr "Repository" + +msgid "Theme by the" +msgstr "Thema von der" + +msgid "Print to PDF" +msgstr "In PDF drucken" + +msgid "Download this page" +msgstr "Laden Sie diese Seite herunter" + +msgid "Copyright" +msgstr "Urheberrechte ©" + +msgid "Last updated on" +msgstr "Zuletzt aktualisiert am" + +msgid "Launch" +msgstr "Starten" + +msgid "Open an issue" +msgstr "Öffnen Sie ein Problem" + +msgid "Fullscreen mode" +msgstr "Vollbildmodus" + +msgid "Sphinx Book Theme" +msgstr "Sphinx-Buch-Thema" + +msgid "Contents" +msgstr "Inhalt" + +msgid "Edit this page" +msgstr "Bearbeite diese Seite" + +msgid "next page" +msgstr "Nächste Seite" + +msgid "Source repository" +msgstr "Quell-Repository" + +msgid "By" +msgstr "Durch" + +msgid "By the" +msgstr "Bis zum" + +msgid "previous page" +msgstr "vorherige Seite" diff --git a/_static/locales/el/LC_MESSAGES/booktheme.mo b/_static/locales/el/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..fca6e9355 Binary files /dev/null and b/_static/locales/el/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/el/LC_MESSAGES/booktheme.po b/_static/locales/el/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..588f2efd8 --- /dev/null +++ b/_static/locales/el/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: el\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Λήψη αρχείου προέλευσης" + +msgid "suggest edit" +msgstr "προτείνω επεξεργασία" + +msgid "Toggle navigation" +msgstr "Εναλλαγή πλοήγησης" + +msgid "open issue" +msgstr "ανοιχτό ζήτημα" + +msgid "Download notebook file" +msgstr "Λήψη αρχείου σημειωματάριου" + +msgid "repository" +msgstr "αποθήκη" + +msgid "Theme by the" +msgstr "Θέμα από το" + +msgid "Print to PDF" +msgstr "Εκτύπωση σε PDF" + +msgid "Download this page" +msgstr "Λήψη αυτής της σελίδας" + +msgid "Copyright" +msgstr "Πνευματική ιδιοκτησία" + +msgid "Last updated on" +msgstr "Τελευταία ενημέρωση στις" + +msgid "Launch" +msgstr "Εκτόξευση" + +msgid "Open an issue" +msgstr "Ανοίξτε ένα ζήτημα" + +msgid "Fullscreen mode" +msgstr "ΛΕΙΤΟΥΡΓΙΑ ΠΛΗΡΟΥΣ ΟΘΟΝΗΣ" + +msgid "Sphinx Book Theme" +msgstr "Θέμα βιβλίου Sphinx" + +msgid "Contents" +msgstr "Περιεχόμενα" + +msgid "Edit this page" +msgstr "Επεξεργαστείτε αυτήν τη σελίδα" + +msgid "next page" +msgstr "επόμενη σελίδα" + +msgid "Source repository" +msgstr "Αποθήκη πηγής" + +msgid "By" +msgstr "Με" + +msgid "By the" +msgstr "Από το" + +msgid "previous page" +msgstr "προηγούμενη σελίδα" diff --git a/_static/locales/eo/LC_MESSAGES/booktheme.mo b/_static/locales/eo/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..d1072bbec Binary files /dev/null and b/_static/locales/eo/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/eo/LC_MESSAGES/booktheme.po b/_static/locales/eo/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..4614fe0aa --- /dev/null +++ b/_static/locales/eo/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: eo\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Elŝutu fontodosieron" + +msgid "suggest edit" +msgstr "sugesti redaktadon" + +msgid "Toggle navigation" +msgstr "Ŝalti navigadon" + +msgid "open issue" +msgstr "malferma numero" + +msgid "Download notebook file" +msgstr "Elŝutu kajeran dosieron" + +msgid "repository" +msgstr "deponejo" + +msgid "Theme by the" +msgstr "Temo de la" + +msgid "Print to PDF" +msgstr "Presi al PDF" + +msgid "Download this page" +msgstr "Elŝutu ĉi tiun paĝon" + +msgid "Copyright" +msgstr "Kopirajto" + +msgid "Last updated on" +msgstr "Laste ĝisdatigita la" + +msgid "Launch" +msgstr "Lanĉo" + +msgid "Open an issue" +msgstr "Malfermu numeron" + +msgid "Fullscreen mode" +msgstr "Plenekrana reĝimo" + +msgid "Sphinx Book Theme" +msgstr "Sfinksa Libro-Temo" + +msgid "Contents" +msgstr "Enhavo" + +msgid "Edit this page" +msgstr "Redaktu ĉi tiun paĝon" + +msgid "next page" +msgstr "sekva paĝo" + +msgid "Source repository" +msgstr "Fonto-deponejo" + +msgid "By" +msgstr "De" + +msgid "By the" +msgstr "Per la" + +msgid "previous page" +msgstr "antaŭa paĝo" diff --git a/_static/locales/es/LC_MESSAGES/booktheme.mo b/_static/locales/es/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..ba2ee4dc2 Binary files /dev/null and b/_static/locales/es/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/es/LC_MESSAGES/booktheme.po b/_static/locales/es/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..b4fccf194 --- /dev/null +++ b/_static/locales/es/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: es\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Descargar archivo fuente" + +msgid "suggest edit" +msgstr "sugerir editar" + +msgid "Toggle navigation" +msgstr "Navegación de palanca" + +msgid "open issue" +msgstr "Tema abierto" + +msgid "Download notebook file" +msgstr "Descargar archivo de cuaderno" + +msgid "repository" +msgstr "repositorio" + +msgid "Theme by the" +msgstr "Tema por el" + +msgid "Print to PDF" +msgstr "Imprimir en PDF" + +msgid "Download this page" +msgstr "Descarga esta pagina" + +msgid "Copyright" +msgstr "Derechos de autor" + +msgid "Last updated on" +msgstr "Ultima actualización en" + +msgid "Launch" +msgstr "Lanzamiento" + +msgid "Open an issue" +msgstr "Abrir un problema" + +msgid "Fullscreen mode" +msgstr "Modo de pantalla completa" + +msgid "Sphinx Book Theme" +msgstr "Tema del libro de la esfinge" + +msgid "Contents" +msgstr "Contenido" + +msgid "Edit this page" +msgstr "Edita esta página" + +msgid "next page" +msgstr "siguiente página" + +msgid "Source repository" +msgstr "Repositorio de origen" + +msgid "By" +msgstr "Por" + +msgid "By the" +msgstr "Por el" + +msgid "previous page" +msgstr "pagina anterior" diff --git a/_static/locales/et/LC_MESSAGES/booktheme.mo b/_static/locales/et/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..983b82391 Binary files /dev/null and b/_static/locales/et/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/et/LC_MESSAGES/booktheme.po b/_static/locales/et/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..b748b37f0 --- /dev/null +++ b/_static/locales/et/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: et\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Laadige alla lähtefail" + +msgid "suggest edit" +msgstr "soovita muuta" + +msgid "Toggle navigation" +msgstr "Lülita navigeerimine sisse" + +msgid "open issue" +msgstr "avatud küsimus" + +msgid "Download notebook file" +msgstr "Laadige sülearvuti fail alla" + +msgid "repository" +msgstr "hoidla" + +msgid "Theme by the" +msgstr "Teema" + +msgid "Print to PDF" +msgstr "Prindi PDF-i" + +msgid "Download this page" +msgstr "Laadige see leht alla" + +msgid "Copyright" +msgstr "Autoriõigus" + +msgid "Last updated on" +msgstr "Viimati uuendatud" + +msgid "Launch" +msgstr "Käivitage" + +msgid "Open an issue" +msgstr "Avage probleem" + +msgid "Fullscreen mode" +msgstr "Täisekraanirežiim" + +msgid "Sphinx Book Theme" +msgstr "Sfinksiraamatu teema" + +msgid "Contents" +msgstr "Sisu" + +msgid "Edit this page" +msgstr "Muutke seda lehte" + +msgid "next page" +msgstr "järgmine leht" + +msgid "Source repository" +msgstr "Allikahoidla" + +msgid "By" +msgstr "Kõrval" + +msgid "By the" +msgstr "Autor" + +msgid "previous page" +msgstr "eelmine leht" diff --git a/_static/locales/fi/LC_MESSAGES/booktheme.mo b/_static/locales/fi/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..d8ac05459 Binary files /dev/null and b/_static/locales/fi/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/fi/LC_MESSAGES/booktheme.po b/_static/locales/fi/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..f58cf58d3 --- /dev/null +++ b/_static/locales/fi/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: fi\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Lataa lähdetiedosto" + +msgid "suggest edit" +msgstr "ehdottaa muokkausta" + +msgid "Toggle navigation" +msgstr "Vaihda navigointia" + +msgid "open issue" +msgstr "avoin ongelma" + +msgid "Download notebook file" +msgstr "Lataa muistikirjatiedosto" + +msgid "repository" +msgstr "arkisto" + +msgid "Theme by the" +msgstr "Teeman tekijä" + +msgid "Print to PDF" +msgstr "Tulosta PDF-tiedostoon" + +msgid "Download this page" +msgstr "Lataa tämä sivu" + +msgid "Copyright" +msgstr "Tekijänoikeus" + +msgid "Last updated on" +msgstr "Viimeksi päivitetty" + +msgid "Launch" +msgstr "Tuoda markkinoille" + +msgid "Open an issue" +msgstr "Avaa ongelma" + +msgid "Fullscreen mode" +msgstr "Koko näytön tila" + +msgid "Sphinx Book Theme" +msgstr "Sphinx-kirjan teema" + +msgid "Contents" +msgstr "Sisällys" + +msgid "Edit this page" +msgstr "Muokkaa tätä sivua" + +msgid "next page" +msgstr "seuraava sivu" + +msgid "Source repository" +msgstr "Lähteen arkisto" + +msgid "By" +msgstr "Tekijä" + +msgid "By the" +msgstr "Mukaan" + +msgid "previous page" +msgstr "Edellinen sivu" diff --git a/_static/locales/fr/LC_MESSAGES/booktheme.mo b/_static/locales/fr/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..f663d39f0 Binary files /dev/null and b/_static/locales/fr/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/fr/LC_MESSAGES/booktheme.po b/_static/locales/fr/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..8a6c94619 --- /dev/null +++ b/_static/locales/fr/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: fr\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Télécharger le fichier source" + +msgid "suggest edit" +msgstr "suggestion de modification" + +msgid "Toggle navigation" +msgstr "Basculer la navigation" + +msgid "open issue" +msgstr "signaler un problème" + +msgid "Download notebook file" +msgstr "Télécharger le fichier notebook" + +msgid "repository" +msgstr "dépôt" + +msgid "Theme by the" +msgstr "Thème par le" + +msgid "Print to PDF" +msgstr "Imprimer au format PDF" + +msgid "Download this page" +msgstr "Téléchargez cette page" + +msgid "Copyright" +msgstr "droits d'auteur" + +msgid "Last updated on" +msgstr "Dernière mise à jour le" + +msgid "Launch" +msgstr "lancement" + +msgid "Open an issue" +msgstr "Ouvrez un problème" + +msgid "Fullscreen mode" +msgstr "Mode plein écran" + +msgid "Sphinx Book Theme" +msgstr "Thème du livre Sphinx" + +msgid "Contents" +msgstr "Contenu" + +msgid "Edit this page" +msgstr "Modifier cette page" + +msgid "next page" +msgstr "page suivante" + +msgid "Source repository" +msgstr "Dépôt source" + +msgid "By" +msgstr "Par" + +msgid "By the" +msgstr "Par le" + +msgid "previous page" +msgstr "page précédente" diff --git a/_static/locales/hr/LC_MESSAGES/booktheme.mo b/_static/locales/hr/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..eca4a1a28 Binary files /dev/null and b/_static/locales/hr/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/hr/LC_MESSAGES/booktheme.po b/_static/locales/hr/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..4ceb3899f --- /dev/null +++ b/_static/locales/hr/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: hr\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Preuzmi izvornu datoteku" + +msgid "suggest edit" +msgstr "predloži uređivanje" + +msgid "Toggle navigation" +msgstr "Uključi / isključi navigaciju" + +msgid "open issue" +msgstr "otvoreno izdanje" + +msgid "Download notebook file" +msgstr "Preuzmi datoteku bilježnice" + +msgid "repository" +msgstr "spremište" + +msgid "Theme by the" +msgstr "Tema autora" + +msgid "Print to PDF" +msgstr "Ispis u PDF" + +msgid "Download this page" +msgstr "Preuzmite ovu stranicu" + +msgid "Copyright" +msgstr "Autorska prava" + +msgid "Last updated on" +msgstr "Posljednje ažuriranje:" + +msgid "Launch" +msgstr "Pokrenite" + +msgid "Open an issue" +msgstr "Otvorite izdanje" + +msgid "Fullscreen mode" +msgstr "Način preko cijelog zaslona" + +msgid "Sphinx Book Theme" +msgstr "Tema knjige Sphinx" + +msgid "Contents" +msgstr "Sadržaj" + +msgid "Edit this page" +msgstr "Uredite ovu stranicu" + +msgid "next page" +msgstr "sljedeća stranica" + +msgid "Source repository" +msgstr "Izvorno spremište" + +msgid "By" +msgstr "Po" + +msgid "By the" +msgstr "Od strane" + +msgid "previous page" +msgstr "Prethodna stranica" diff --git a/_static/locales/id/LC_MESSAGES/booktheme.mo b/_static/locales/id/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..d07a06a9d Binary files /dev/null and b/_static/locales/id/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/id/LC_MESSAGES/booktheme.po b/_static/locales/id/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..1eca59947 --- /dev/null +++ b/_static/locales/id/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: id\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Unduh file sumber" + +msgid "suggest edit" +msgstr "menyarankan edit" + +msgid "Toggle navigation" +msgstr "Alihkan navigasi" + +msgid "open issue" +msgstr "masalah terbuka" + +msgid "Download notebook file" +msgstr "Unduh file notebook" + +msgid "repository" +msgstr "gudang" + +msgid "Theme by the" +msgstr "Tema oleh" + +msgid "Print to PDF" +msgstr "Cetak ke PDF" + +msgid "Download this page" +msgstr "Unduh halaman ini" + +msgid "Copyright" +msgstr "hak cipta" + +msgid "Last updated on" +msgstr "Terakhir diperbarui saat" + +msgid "Launch" +msgstr "Meluncurkan" + +msgid "Open an issue" +msgstr "Buka masalah" + +msgid "Fullscreen mode" +msgstr "Mode layar penuh" + +msgid "Sphinx Book Theme" +msgstr "Tema Buku Sphinx" + +msgid "Contents" +msgstr "Isi" + +msgid "Edit this page" +msgstr "Edit halaman ini" + +msgid "next page" +msgstr "halaman selanjutnya" + +msgid "Source repository" +msgstr "Repositori sumber" + +msgid "By" +msgstr "Oleh" + +msgid "By the" +msgstr "Oleh" + +msgid "previous page" +msgstr "halaman sebelumnya" diff --git a/_static/locales/it/LC_MESSAGES/booktheme.mo b/_static/locales/it/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..53ba476ed Binary files /dev/null and b/_static/locales/it/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/it/LC_MESSAGES/booktheme.po b/_static/locales/it/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..f3169000c --- /dev/null +++ b/_static/locales/it/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: it\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Scarica il file sorgente" + +msgid "suggest edit" +msgstr "suggerisci modifica" + +msgid "Toggle navigation" +msgstr "Attiva / disattiva la navigazione" + +msgid "open issue" +msgstr "questione aperta" + +msgid "Download notebook file" +msgstr "Scarica il file del taccuino" + +msgid "repository" +msgstr "repository" + +msgid "Theme by the" +msgstr "Tema di" + +msgid "Print to PDF" +msgstr "Stampa in PDF" + +msgid "Download this page" +msgstr "Scarica questa pagina" + +msgid "Copyright" +msgstr "Diritto d'autore" + +msgid "Last updated on" +msgstr "Ultimo aggiornamento il" + +msgid "Launch" +msgstr "Lanciare" + +msgid "Open an issue" +msgstr "Apri un problema" + +msgid "Fullscreen mode" +msgstr "Modalità schermo intero" + +msgid "Sphinx Book Theme" +msgstr "Tema del libro della Sfinge" + +msgid "Contents" +msgstr "Contenuti" + +msgid "Edit this page" +msgstr "Modifica questa pagina" + +msgid "next page" +msgstr "pagina successiva" + +msgid "Source repository" +msgstr "Repository di origine" + +msgid "By" +msgstr "Di" + +msgid "By the" +msgstr "Dal" + +msgid "previous page" +msgstr "pagina precedente" diff --git a/_static/locales/iw/LC_MESSAGES/booktheme.mo b/_static/locales/iw/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..a45c6575e Binary files /dev/null and b/_static/locales/iw/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/iw/LC_MESSAGES/booktheme.po b/_static/locales/iw/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..9e6d753e7 --- /dev/null +++ b/_static/locales/iw/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: iw\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "הורד את קובץ המקור" + +msgid "suggest edit" +msgstr "מציע לערוך" + +msgid "Toggle navigation" +msgstr "החלף ניווט" + +msgid "open issue" +msgstr "בעיה פתוחה" + +msgid "Download notebook file" +msgstr "הורד קובץ מחברת" + +msgid "repository" +msgstr "מאגר" + +msgid "Theme by the" +msgstr "נושא מאת" + +msgid "Print to PDF" +msgstr "הדפס לקובץ PDF" + +msgid "Download this page" +msgstr "הורד דף זה" + +msgid "Copyright" +msgstr "זכויות יוצרים" + +msgid "Last updated on" +msgstr "עודכן לאחרונה ב" + +msgid "Launch" +msgstr "לְהַשִׁיק" + +msgid "Open an issue" +msgstr "פתח גיליון" + +msgid "Fullscreen mode" +msgstr "מצב מסך מלא" + +msgid "Sphinx Book Theme" +msgstr "נושא ספר ספינקס" + +msgid "Contents" +msgstr "תוכן" + +msgid "Edit this page" +msgstr "ערוך דף זה" + +msgid "next page" +msgstr "עמוד הבא" + +msgid "Source repository" +msgstr "מאגר המקורות" + +msgid "By" +msgstr "על ידי" + +msgid "By the" +msgstr "דרך" + +msgid "previous page" +msgstr "עמוד קודם" diff --git a/_static/locales/ja/LC_MESSAGES/booktheme.mo b/_static/locales/ja/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..1cefd29ce Binary files /dev/null and b/_static/locales/ja/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ja/LC_MESSAGES/booktheme.po b/_static/locales/ja/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..c1a314896 --- /dev/null +++ b/_static/locales/ja/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ja\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "ソースファイルをダウンロード" + +msgid "suggest edit" +msgstr "編集を提案する" + +msgid "Toggle navigation" +msgstr "ナビゲーションを切り替え" + +msgid "open issue" +msgstr "未解決の問題" + +msgid "Download notebook file" +msgstr "ノートブックファイルをダウンロード" + +msgid "repository" +msgstr "リポジトリ" + +msgid "Theme by the" +msgstr "のテーマ" + +msgid "Print to PDF" +msgstr "PDFに印刷" + +msgid "Download this page" +msgstr "このページをダウンロード" + +msgid "Copyright" +msgstr "Copyright" + +msgid "Last updated on" +msgstr "最終更新日" + +msgid "Launch" +msgstr "起動" + +msgid "Open an issue" +msgstr "問題を報告" + +msgid "Fullscreen mode" +msgstr "全画面モード" + +msgid "Sphinx Book Theme" +msgstr "スフィンクスの本のテーマ" + +msgid "Contents" +msgstr "目次" + +msgid "Edit this page" +msgstr "このページを編集" + +msgid "next page" +msgstr "次のページ" + +msgid "Source repository" +msgstr "ソースリポジトリ" + +msgid "By" +msgstr "著者" + +msgid "By the" +msgstr "によって" + +msgid "previous page" +msgstr "前のページ" diff --git a/_static/locales/ko/LC_MESSAGES/booktheme.mo b/_static/locales/ko/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..06c7ec938 Binary files /dev/null and b/_static/locales/ko/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ko/LC_MESSAGES/booktheme.po b/_static/locales/ko/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..80142313b --- /dev/null +++ b/_static/locales/ko/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ko\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "소스 파일 다운로드" + +msgid "suggest edit" +msgstr "편집 제안" + +msgid "Toggle navigation" +msgstr "탐색 전환" + +msgid "open issue" +msgstr "열린 문제" + +msgid "Download notebook file" +msgstr "노트북 파일 다운로드" + +msgid "repository" +msgstr "저장소" + +msgid "Theme by the" +msgstr "테마별" + +msgid "Print to PDF" +msgstr "PDF로 인쇄" + +msgid "Download this page" +msgstr "이 페이지 다운로드" + +msgid "Copyright" +msgstr "저작권" + +msgid "Last updated on" +msgstr "마지막 업데이트" + +msgid "Launch" +msgstr "시작하다" + +msgid "Open an issue" +msgstr "이슈 열기" + +msgid "Fullscreen mode" +msgstr "전체 화면으로보기" + +msgid "Sphinx Book Theme" +msgstr "스핑크스 도서 테마" + +msgid "Contents" +msgstr "내용" + +msgid "Edit this page" +msgstr "이 페이지 편집" + +msgid "next page" +msgstr "다음 페이지" + +msgid "Source repository" +msgstr "소스 저장소" + +msgid "By" +msgstr "으로" + +msgid "By the" +msgstr "에 의해" + +msgid "previous page" +msgstr "이전 페이지" diff --git a/_static/locales/lt/LC_MESSAGES/booktheme.mo b/_static/locales/lt/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..4468ba04b Binary files /dev/null and b/_static/locales/lt/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/lt/LC_MESSAGES/booktheme.po b/_static/locales/lt/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..2e6915a9f --- /dev/null +++ b/_static/locales/lt/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: lt\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Atsisiųsti šaltinio failą" + +msgid "suggest edit" +msgstr "pasiūlyti redaguoti" + +msgid "Toggle navigation" +msgstr "Perjungti naršymą" + +msgid "open issue" +msgstr "atviras klausimas" + +msgid "Download notebook file" +msgstr "Atsisiųsti nešiojamojo kompiuterio failą" + +msgid "repository" +msgstr "saugykla" + +msgid "Theme by the" +msgstr "Tema" + +msgid "Print to PDF" +msgstr "Spausdinti į PDF" + +msgid "Download this page" +msgstr "Atsisiųskite šį puslapį" + +msgid "Copyright" +msgstr "Autorių teisės" + +msgid "Last updated on" +msgstr "Paskutinį kartą atnaujinta" + +msgid "Launch" +msgstr "Paleiskite" + +msgid "Open an issue" +msgstr "Atidarykite problemą" + +msgid "Fullscreen mode" +msgstr "Pilno ekrano režimas" + +msgid "Sphinx Book Theme" +msgstr "Sfinkso knygos tema" + +msgid "Contents" +msgstr "Turinys" + +msgid "Edit this page" +msgstr "Redaguoti šį puslapį" + +msgid "next page" +msgstr "Kitas puslapis" + +msgid "Source repository" +msgstr "Šaltinio saugykla" + +msgid "By" +msgstr "Iki" + +msgid "By the" +msgstr "Prie" + +msgid "previous page" +msgstr "Ankstesnis puslapis" diff --git a/_static/locales/lv/LC_MESSAGES/booktheme.mo b/_static/locales/lv/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..74aa4d898 Binary files /dev/null and b/_static/locales/lv/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/lv/LC_MESSAGES/booktheme.po b/_static/locales/lv/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..d4f4b1507 --- /dev/null +++ b/_static/locales/lv/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: lv\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Lejupielādēt avota failu" + +msgid "suggest edit" +msgstr "ieteikt rediģēt" + +msgid "Toggle navigation" +msgstr "Pārslēgt navigāciju" + +msgid "open issue" +msgstr "atklāts jautājums" + +msgid "Download notebook file" +msgstr "Lejupielādēt piezīmju grāmatiņu" + +msgid "repository" +msgstr "krātuve" + +msgid "Theme by the" +msgstr "Autora tēma" + +msgid "Print to PDF" +msgstr "Drukāt PDF formātā" + +msgid "Download this page" +msgstr "Lejupielādējiet šo lapu" + +msgid "Copyright" +msgstr "Autortiesības" + +msgid "Last updated on" +msgstr "Pēdējoreiz atjaunināts" + +msgid "Launch" +msgstr "Uzsākt" + +msgid "Open an issue" +msgstr "Atveriet problēmu" + +msgid "Fullscreen mode" +msgstr "Pilnekrāna režīms" + +msgid "Sphinx Book Theme" +msgstr "Sfinksa grāmatas tēma" + +msgid "Contents" +msgstr "Saturs" + +msgid "Edit this page" +msgstr "Rediģēt šo lapu" + +msgid "next page" +msgstr "nākamā lapaspuse" + +msgid "Source repository" +msgstr "Avota krātuve" + +msgid "By" +msgstr "Autors" + +msgid "By the" +msgstr "Ar" + +msgid "previous page" +msgstr "iepriekšējā lapa" diff --git a/_static/locales/ml/LC_MESSAGES/booktheme.mo b/_static/locales/ml/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..2736e8fcf Binary files /dev/null and b/_static/locales/ml/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ml/LC_MESSAGES/booktheme.po b/_static/locales/ml/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..5d8ed33b6 --- /dev/null +++ b/_static/locales/ml/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ml\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "ഉറവിട ഫയൽ ഡൗൺലോഡുചെയ്യുക" + +msgid "suggest edit" +msgstr "എഡിറ്റുചെയ്യാൻ നിർദ്ദേശിക്കുക" + +msgid "Toggle navigation" +msgstr "നാവിഗേഷൻ ടോഗിൾ ചെയ്യുക" + +msgid "open issue" +msgstr "തുറന്ന പ്രശ്നം" + +msgid "Download notebook file" +msgstr "നോട്ട്ബുക്ക് ഫയൽ ഡൺലോഡ് ചെയ്യുക" + +msgid "Theme by the" +msgstr "പ്രമേയം" + +msgid "Print to PDF" +msgstr "PDF- ലേക്ക് പ്രിന്റുചെയ്യുക" + +msgid "Download this page" +msgstr "ഈ പേജ് ഡൗൺലോഡുചെയ്യുക" + +msgid "Copyright" +msgstr "പകർപ്പവകാശം" + +msgid "Last updated on" +msgstr "അവസാനം അപ്‌ഡേറ്റുചെയ്‌തത്" + +msgid "Launch" +msgstr "സമാരംഭിക്കുക" + +msgid "Open an issue" +msgstr "ഒരു പ്രശ്നം തുറക്കുക" + +msgid "Sphinx Book Theme" +msgstr "സ്ഫിങ്ക്സ് പുസ്തക തീം" + +msgid "Edit this page" +msgstr "ഈ പേജ് എഡിറ്റുചെയ്യുക" + +msgid "next page" +msgstr "അടുത്ത പേജ്" + +msgid "Source repository" +msgstr "ഉറവിട ശേഖരം" + +msgid "By" +msgstr "എഴുതിയത്" + +msgid "By the" +msgstr "എഴുതിയത്" + +msgid "previous page" +msgstr "മുൻപത്തെ താൾ" diff --git a/_static/locales/mr/LC_MESSAGES/booktheme.mo b/_static/locales/mr/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..fe530100d Binary files /dev/null and b/_static/locales/mr/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/mr/LC_MESSAGES/booktheme.po b/_static/locales/mr/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..64389fac9 --- /dev/null +++ b/_static/locales/mr/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: mr\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "स्त्रोत फाइल डाउनलोड करा" + +msgid "suggest edit" +msgstr "संपादन सुचवा" + +msgid "Toggle navigation" +msgstr "नेव्हिगेशन टॉगल करा" + +msgid "open issue" +msgstr "खुला मुद्दा" + +msgid "Download notebook file" +msgstr "नोटबुक फाईल डाउनलोड करा" + +msgid "Theme by the" +msgstr "द्वारा थीम" + +msgid "Print to PDF" +msgstr "पीडीएफवर मुद्रित करा" + +msgid "Download this page" +msgstr "हे पृष्ठ डाउनलोड करा" + +msgid "Copyright" +msgstr "कॉपीराइट" + +msgid "Last updated on" +msgstr "अखेरचे अद्यतनित" + +msgid "Launch" +msgstr "लाँच करा" + +msgid "Open an issue" +msgstr "एक मुद्दा उघडा" + +msgid "Sphinx Book Theme" +msgstr "स्फिंक्स बुक थीम" + +msgid "Edit this page" +msgstr "हे पृष्ठ संपादित करा" + +msgid "next page" +msgstr "पुढील पृष्ठ" + +msgid "Source repository" +msgstr "स्त्रोत भांडार" + +msgid "By" +msgstr "द्वारा" + +msgid "By the" +msgstr "द्वारा" + +msgid "previous page" +msgstr "मागील पान" diff --git a/_static/locales/ms/LC_MESSAGES/booktheme.mo b/_static/locales/ms/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..f02603fa2 Binary files /dev/null and b/_static/locales/ms/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ms/LC_MESSAGES/booktheme.po b/_static/locales/ms/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..4365ff549 --- /dev/null +++ b/_static/locales/ms/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ms\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Muat turun fail sumber" + +msgid "suggest edit" +msgstr "cadangkan edit" + +msgid "Toggle navigation" +msgstr "Togol navigasi" + +msgid "open issue" +msgstr "isu terbuka" + +msgid "Download notebook file" +msgstr "Muat turun fail buku nota" + +msgid "Theme by the" +msgstr "Tema oleh" + +msgid "Print to PDF" +msgstr "Cetak ke PDF" + +msgid "Download this page" +msgstr "Muat turun halaman ini" + +msgid "Copyright" +msgstr "hak cipta" + +msgid "Last updated on" +msgstr "Terakhir dikemas kini pada" + +msgid "Launch" +msgstr "Lancarkan" + +msgid "Open an issue" +msgstr "Buka masalah" + +msgid "Sphinx Book Theme" +msgstr "Tema Buku Sphinx" + +msgid "Edit this page" +msgstr "Edit halaman ini" + +msgid "next page" +msgstr "muka surat seterusnya" + +msgid "Source repository" +msgstr "Repositori sumber" + +msgid "By" +msgstr "Oleh" + +msgid "By the" +msgstr "Oleh" + +msgid "previous page" +msgstr "halaman sebelumnya" diff --git a/_static/locales/nl/LC_MESSAGES/booktheme.mo b/_static/locales/nl/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..e59e7ecb3 Binary files /dev/null and b/_static/locales/nl/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/nl/LC_MESSAGES/booktheme.po b/_static/locales/nl/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..f7b18e5d5 --- /dev/null +++ b/_static/locales/nl/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: nl\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Download het bronbestand" + +msgid "suggest edit" +msgstr "suggereren bewerken" + +msgid "Toggle navigation" +msgstr "Schakel navigatie" + +msgid "open issue" +msgstr "open probleem" + +msgid "Download notebook file" +msgstr "Download notebookbestand" + +msgid "repository" +msgstr "repository" + +msgid "Theme by the" +msgstr "Thema door de" + +msgid "Print to PDF" +msgstr "Afdrukken naar pdf" + +msgid "Download this page" +msgstr "Download deze pagina" + +msgid "Copyright" +msgstr "auteursrechten" + +msgid "Last updated on" +msgstr "Laatst geupdate op" + +msgid "Launch" +msgstr "Lancering" + +msgid "Open an issue" +msgstr "Open een probleem" + +msgid "Fullscreen mode" +msgstr "Volledig scherm" + +msgid "Sphinx Book Theme" +msgstr "Sphinx-boekthema" + +msgid "Contents" +msgstr "Inhoud" + +msgid "Edit this page" +msgstr "bewerk deze pagina" + +msgid "next page" +msgstr "volgende bladzijde" + +msgid "Source repository" +msgstr "Bronopslagplaats" + +msgid "By" +msgstr "Door" + +msgid "By the" +msgstr "Door de" + +msgid "previous page" +msgstr "vorige pagina" diff --git a/_static/locales/no/LC_MESSAGES/booktheme.mo b/_static/locales/no/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..6cd15c88d Binary files /dev/null and b/_static/locales/no/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/no/LC_MESSAGES/booktheme.po b/_static/locales/no/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..274823a86 --- /dev/null +++ b/_static/locales/no/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: no\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Last ned kildefilen" + +msgid "suggest edit" +msgstr "foreslå redigering" + +msgid "Toggle navigation" +msgstr "Bytt navigasjon" + +msgid "open issue" +msgstr "åpent nummer" + +msgid "Download notebook file" +msgstr "Last ned notatbokfilen" + +msgid "repository" +msgstr "oppbevaringssted" + +msgid "Theme by the" +msgstr "Tema av" + +msgid "Print to PDF" +msgstr "Skriv ut til PDF" + +msgid "Download this page" +msgstr "Last ned denne siden" + +msgid "Copyright" +msgstr "opphavsrett" + +msgid "Last updated on" +msgstr "Sist oppdatert den" + +msgid "Launch" +msgstr "Start" + +msgid "Open an issue" +msgstr "Åpne et problem" + +msgid "Fullscreen mode" +msgstr "Fullskjerm-modus" + +msgid "Sphinx Book Theme" +msgstr "Sphinx boktema" + +msgid "Contents" +msgstr "Innhold" + +msgid "Edit this page" +msgstr "Rediger denne siden" + +msgid "next page" +msgstr "neste side" + +msgid "Source repository" +msgstr "Kildedepot" + +msgid "By" +msgstr "Av" + +msgid "By the" +msgstr "Ved" + +msgid "previous page" +msgstr "forrige side" diff --git a/_static/locales/pl/LC_MESSAGES/booktheme.mo b/_static/locales/pl/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..9ebb584f7 Binary files /dev/null and b/_static/locales/pl/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/pl/LC_MESSAGES/booktheme.po b/_static/locales/pl/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..dfba3f698 --- /dev/null +++ b/_static/locales/pl/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: pl\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Pobierz plik źródłowy" + +msgid "suggest edit" +msgstr "zaproponuj edycję" + +msgid "Toggle navigation" +msgstr "Przełącz nawigację" + +msgid "open issue" +msgstr "otwarty problem" + +msgid "Download notebook file" +msgstr "Pobierz plik notatnika" + +msgid "repository" +msgstr "magazyn" + +msgid "Theme by the" +msgstr "Motyw autorstwa" + +msgid "Print to PDF" +msgstr "Drukuj do PDF" + +msgid "Download this page" +msgstr "Pobierz tę stronę" + +msgid "Copyright" +msgstr "prawa autorskie" + +msgid "Last updated on" +msgstr "Ostatnia aktualizacja" + +msgid "Launch" +msgstr "Uruchomić" + +msgid "Open an issue" +msgstr "Otwórz problem" + +msgid "Fullscreen mode" +msgstr "Pełny ekran" + +msgid "Sphinx Book Theme" +msgstr "Motyw książki Sphinx" + +msgid "Contents" +msgstr "Zawartość" + +msgid "Edit this page" +msgstr "Edytuj tę strone" + +msgid "next page" +msgstr "Następna strona" + +msgid "Source repository" +msgstr "Repozytorium źródłowe" + +msgid "By" +msgstr "Przez" + +msgid "By the" +msgstr "Przez" + +msgid "previous page" +msgstr "Poprzednia strona" diff --git a/_static/locales/pt/LC_MESSAGES/booktheme.mo b/_static/locales/pt/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..d0ddb8728 Binary files /dev/null and b/_static/locales/pt/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/pt/LC_MESSAGES/booktheme.po b/_static/locales/pt/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..4c24eb9e2 --- /dev/null +++ b/_static/locales/pt/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: pt\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Baixar arquivo fonte" + +msgid "suggest edit" +msgstr "sugerir edição" + +msgid "Toggle navigation" +msgstr "Alternar de navegação" + +msgid "open issue" +msgstr "questão aberta" + +msgid "Download notebook file" +msgstr "Baixar arquivo de notebook" + +msgid "repository" +msgstr "repositório" + +msgid "Theme by the" +msgstr "Tema por" + +msgid "Print to PDF" +msgstr "Imprimir em PDF" + +msgid "Download this page" +msgstr "Baixe esta página" + +msgid "Copyright" +msgstr "direito autoral" + +msgid "Last updated on" +msgstr "Última atualização em" + +msgid "Launch" +msgstr "Lançamento" + +msgid "Open an issue" +msgstr "Abra um problema" + +msgid "Fullscreen mode" +msgstr "Modo tela cheia" + +msgid "Sphinx Book Theme" +msgstr "Tema do livro Sphinx" + +msgid "Contents" +msgstr "Conteúdo" + +msgid "Edit this page" +msgstr "Edite essa página" + +msgid "next page" +msgstr "próxima página" + +msgid "Source repository" +msgstr "Repositório fonte" + +msgid "By" +msgstr "De" + +msgid "By the" +msgstr "Pelo" + +msgid "previous page" +msgstr "página anterior" diff --git a/_static/locales/ro/LC_MESSAGES/booktheme.mo b/_static/locales/ro/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..3c36ab1df Binary files /dev/null and b/_static/locales/ro/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ro/LC_MESSAGES/booktheme.po b/_static/locales/ro/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..5f03d9cdb --- /dev/null +++ b/_static/locales/ro/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ro\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Descărcați fișierul sursă" + +msgid "suggest edit" +msgstr "sugerează editare" + +msgid "Toggle navigation" +msgstr "Comutare navigare" + +msgid "open issue" +msgstr "problema deschisă" + +msgid "Download notebook file" +msgstr "Descărcați fișierul notebook" + +msgid "repository" +msgstr "repertoriu" + +msgid "Theme by the" +msgstr "Tema de" + +msgid "Print to PDF" +msgstr "Imprimați în PDF" + +msgid "Download this page" +msgstr "Descarcă această pagină" + +msgid "Copyright" +msgstr "Drepturi de autor" + +msgid "Last updated on" +msgstr "Ultima actualizare la" + +msgid "Launch" +msgstr "Lansa" + +msgid "Open an issue" +msgstr "Deschideți o problemă" + +msgid "Fullscreen mode" +msgstr "Modul ecran întreg" + +msgid "Sphinx Book Theme" +msgstr "Tema Sphinx Book" + +msgid "Contents" +msgstr "Cuprins" + +msgid "Edit this page" +msgstr "Editați această pagină" + +msgid "next page" +msgstr "pagina următoare" + +msgid "Source repository" +msgstr "Depozit sursă" + +msgid "By" +msgstr "De" + +msgid "By the" +msgstr "Langa" + +msgid "previous page" +msgstr "pagina anterioară" diff --git a/_static/locales/ru/LC_MESSAGES/booktheme.mo b/_static/locales/ru/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..6b8ca41f3 Binary files /dev/null and b/_static/locales/ru/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ru/LC_MESSAGES/booktheme.po b/_static/locales/ru/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..2886570d0 --- /dev/null +++ b/_static/locales/ru/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ru\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Скачать исходный файл" + +msgid "suggest edit" +msgstr "предложить редактировать" + +msgid "Toggle navigation" +msgstr "Переключить навигацию" + +msgid "open issue" +msgstr "открытый вопрос" + +msgid "Download notebook file" +msgstr "Скачать файл записной книжки" + +msgid "repository" +msgstr "хранилище" + +msgid "Theme by the" +msgstr "Тема от" + +msgid "Print to PDF" +msgstr "Распечатать в PDF" + +msgid "Download this page" +msgstr "Загрузите эту страницу" + +msgid "Copyright" +msgstr "авторское право" + +msgid "Last updated on" +msgstr "Последнее обновление" + +msgid "Launch" +msgstr "Запуск" + +msgid "Open an issue" +msgstr "Открыть вопрос" + +msgid "Fullscreen mode" +msgstr "Полноэкранный режим" + +msgid "Sphinx Book Theme" +msgstr "Тема книги Сфинкс" + +msgid "Contents" +msgstr "Содержание" + +msgid "Edit this page" +msgstr "Редактировать эту страницу" + +msgid "next page" +msgstr "Следующая страница" + +msgid "Source repository" +msgstr "Исходный репозиторий" + +msgid "By" +msgstr "По" + +msgid "By the" +msgstr "Посредством" + +msgid "previous page" +msgstr "Предыдущая страница" diff --git a/_static/locales/sk/LC_MESSAGES/booktheme.mo b/_static/locales/sk/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..59bd0ddfa Binary files /dev/null and b/_static/locales/sk/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/sk/LC_MESSAGES/booktheme.po b/_static/locales/sk/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..25517aa5a --- /dev/null +++ b/_static/locales/sk/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: sk\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Stiahnite si zdrojový súbor" + +msgid "suggest edit" +msgstr "navrhnúť úpravu" + +msgid "Toggle navigation" +msgstr "Prepnúť navigáciu" + +msgid "open issue" +msgstr "otvorené vydanie" + +msgid "Download notebook file" +msgstr "Stiahnite si zošit" + +msgid "repository" +msgstr "Úložisko" + +msgid "Theme by the" +msgstr "Téma od" + +msgid "Print to PDF" +msgstr "Tlač do PDF" + +msgid "Download this page" +msgstr "Stiahnite si túto stránku" + +msgid "Copyright" +msgstr "Autorské práva" + +msgid "Last updated on" +msgstr "Posledná aktualizácia dňa" + +msgid "Launch" +msgstr "Spustiť" + +msgid "Open an issue" +msgstr "Otvorte problém" + +msgid "Fullscreen mode" +msgstr "Režim celej obrazovky" + +msgid "Sphinx Book Theme" +msgstr "Téma knihy Sfinga" + +msgid "Contents" +msgstr "Obsah" + +msgid "Edit this page" +msgstr "Upraviť túto stránku" + +msgid "next page" +msgstr "ďalšia strana" + +msgid "Source repository" +msgstr "Zdrojové úložisko" + +msgid "By" +msgstr "Autor:" + +msgid "By the" +msgstr "Podľa" + +msgid "previous page" +msgstr "predchádzajúca strana" diff --git a/_static/locales/sl/LC_MESSAGES/booktheme.mo b/_static/locales/sl/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..87bf26de6 Binary files /dev/null and b/_static/locales/sl/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/sl/LC_MESSAGES/booktheme.po b/_static/locales/sl/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..346c36484 --- /dev/null +++ b/_static/locales/sl/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: sl\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Prenesite izvorno datoteko" + +msgid "suggest edit" +msgstr "predlagajte urejanje" + +msgid "Toggle navigation" +msgstr "Preklopi navigacijo" + +msgid "open issue" +msgstr "odprto vprašanje" + +msgid "Download notebook file" +msgstr "Prenesite datoteko zvezka" + +msgid "repository" +msgstr "odlagališče" + +msgid "Theme by the" +msgstr "Tema avtorja" + +msgid "Print to PDF" +msgstr "Natisni v PDF" + +msgid "Download this page" +msgstr "Prenesite to stran" + +msgid "Copyright" +msgstr "avtorske pravice" + +msgid "Last updated on" +msgstr "Nazadnje posodobljeno dne" + +msgid "Launch" +msgstr "Kosilo" + +msgid "Open an issue" +msgstr "Odprite številko" + +msgid "Fullscreen mode" +msgstr "Celozaslonski način" + +msgid "Sphinx Book Theme" +msgstr "Tema knjige Sphinx" + +msgid "Contents" +msgstr "Vsebina" + +msgid "Edit this page" +msgstr "Uredite to stran" + +msgid "next page" +msgstr "Naslednja stran" + +msgid "Source repository" +msgstr "Izvorno skladišče" + +msgid "By" +msgstr "Avtor" + +msgid "By the" +msgstr "Avtor" + +msgid "previous page" +msgstr "Prejšnja stran" diff --git a/_static/locales/sr/LC_MESSAGES/booktheme.mo b/_static/locales/sr/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..ec740f485 Binary files /dev/null and b/_static/locales/sr/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/sr/LC_MESSAGES/booktheme.po b/_static/locales/sr/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..b1a97adac --- /dev/null +++ b/_static/locales/sr/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: sr\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Преузми изворну датотеку" + +msgid "suggest edit" +msgstr "предложи уређивање" + +msgid "Toggle navigation" +msgstr "Укључи / искључи навигацију" + +msgid "open issue" +msgstr "отворено издање" + +msgid "Download notebook file" +msgstr "Преузмите датотеку бележнице" + +msgid "repository" +msgstr "спремиште" + +msgid "Theme by the" +msgstr "Тхеме би" + +msgid "Print to PDF" +msgstr "Испис у ПДФ" + +msgid "Download this page" +msgstr "Преузмите ову страницу" + +msgid "Copyright" +msgstr "Ауторско право" + +msgid "Last updated on" +msgstr "Последње ажурирање" + +msgid "Launch" +msgstr "Лансирање" + +msgid "Open an issue" +msgstr "Отворите издање" + +msgid "Fullscreen mode" +msgstr "Режим целог екрана" + +msgid "Sphinx Book Theme" +msgstr "Тема књиге Спхинк" + +msgid "Contents" +msgstr "Садржај" + +msgid "Edit this page" +msgstr "Уредите ову страницу" + +msgid "next page" +msgstr "Следећа страна" + +msgid "Source repository" +msgstr "Изворно спремиште" + +msgid "By" +msgstr "Од стране" + +msgid "By the" +msgstr "Од" + +msgid "previous page" +msgstr "Претходна страница" diff --git a/_static/locales/sv/LC_MESSAGES/booktheme.mo b/_static/locales/sv/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..b07dc76ff Binary files /dev/null and b/_static/locales/sv/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/sv/LC_MESSAGES/booktheme.po b/_static/locales/sv/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..8fc0146e6 --- /dev/null +++ b/_static/locales/sv/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: sv\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Ladda ner källfil" + +msgid "suggest edit" +msgstr "föreslå ändring" + +msgid "Toggle navigation" +msgstr "Växla navigering" + +msgid "open issue" +msgstr "öppna problemrapport" + +msgid "Download notebook file" +msgstr "Ladda ner notebook-fil" + +msgid "repository" +msgstr "repositorium" + +msgid "Theme by the" +msgstr "Tema av" + +msgid "Print to PDF" +msgstr "Skriv ut till PDF" + +msgid "Download this page" +msgstr "Ladda ner den här sidan" + +msgid "Copyright" +msgstr "Upphovsrätt" + +msgid "Last updated on" +msgstr "Senast uppdaterad den" + +msgid "Launch" +msgstr "Öppna" + +msgid "Open an issue" +msgstr "Öppna en problemrapport" + +msgid "Fullscreen mode" +msgstr "Fullskärmsläge" + +msgid "Sphinx Book Theme" +msgstr "Sphinx Boktema" + +msgid "Contents" +msgstr "Innehåll" + +msgid "Edit this page" +msgstr "Redigera den här sidan" + +msgid "next page" +msgstr "nästa sida" + +msgid "Source repository" +msgstr "Källkodsrepositorium" + +msgid "By" +msgstr "Av" + +msgid "By the" +msgstr "Av den" + +msgid "previous page" +msgstr "föregående sida" diff --git a/_static/locales/ta/LC_MESSAGES/booktheme.mo b/_static/locales/ta/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..29f52e1f6 Binary files /dev/null and b/_static/locales/ta/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ta/LC_MESSAGES/booktheme.po b/_static/locales/ta/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..116d74331 --- /dev/null +++ b/_static/locales/ta/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ta\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "மூல கோப்பைப் பதிவிறக்குக" + +msgid "suggest edit" +msgstr "திருத்த பரிந்துரைக்கவும்" + +msgid "Toggle navigation" +msgstr "வழிசெலுத்தலை நிலைமாற்று" + +msgid "open issue" +msgstr "திறந்த பிரச்சினை" + +msgid "Download notebook file" +msgstr "நோட்புக் கோப்பைப் பதிவிறக்கவும்" + +msgid "Theme by the" +msgstr "வழங்கிய தீம்" + +msgid "Print to PDF" +msgstr "PDF இல் அச்சிடுக" + +msgid "Download this page" +msgstr "இந்தப் பக்கத்தைப் பதிவிறக்கவும்" + +msgid "Copyright" +msgstr "பதிப்புரிமை" + +msgid "Last updated on" +msgstr "கடைசியாக புதுப்பிக்கப்பட்டது" + +msgid "Launch" +msgstr "தொடங்க" + +msgid "Open an issue" +msgstr "சிக்கலைத் திறக்கவும்" + +msgid "Sphinx Book Theme" +msgstr "ஸ்பிங்க்ஸ் புத்தக தீம்" + +msgid "Edit this page" +msgstr "இந்தப் பக்கத்தைத் திருத்தவும்" + +msgid "next page" +msgstr "அடுத்த பக்கம்" + +msgid "Source repository" +msgstr "மூல களஞ்சியம்" + +msgid "By" +msgstr "வழங்கியவர்" + +msgid "By the" +msgstr "மூலம்" + +msgid "previous page" +msgstr "முந்தைய பக்கம்" diff --git a/_static/locales/te/LC_MESSAGES/booktheme.mo b/_static/locales/te/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..0a5f4b46a Binary files /dev/null and b/_static/locales/te/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/te/LC_MESSAGES/booktheme.po b/_static/locales/te/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..635bdf962 --- /dev/null +++ b/_static/locales/te/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: te\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "మూల ఫైల్‌ను డౌన్‌లోడ్ చేయండి" + +msgid "suggest edit" +msgstr "సవరించమని సూచించండి" + +msgid "Toggle navigation" +msgstr "నావిగేషన్‌ను టోగుల్ చేయండి" + +msgid "open issue" +msgstr "ఓపెన్ ఇష్యూ" + +msgid "Download notebook file" +msgstr "నోట్బుక్ ఫైల్ను డౌన్లోడ్ చేయండి" + +msgid "Theme by the" +msgstr "ద్వారా థీమ్" + +msgid "Print to PDF" +msgstr "PDF కి ముద్రించండి" + +msgid "Download this page" +msgstr "ఈ పేజీని డౌన్‌లోడ్ చేయండి" + +msgid "Copyright" +msgstr "కాపీరైట్" + +msgid "Last updated on" +msgstr "చివరిగా నవీకరించబడింది" + +msgid "Launch" +msgstr "ప్రారంభించండి" + +msgid "Open an issue" +msgstr "సమస్యను తెరవండి" + +msgid "Sphinx Book Theme" +msgstr "సింహిక పుస్తక థీమ్" + +msgid "Edit this page" +msgstr "ఈ పేజీని సవరించండి" + +msgid "next page" +msgstr "తరువాతి పేజీ" + +msgid "Source repository" +msgstr "మూల రిపోజిటరీ" + +msgid "By" +msgstr "ద్వారా" + +msgid "By the" +msgstr "ద్వారా" + +msgid "previous page" +msgstr "ముందు పేజి" diff --git a/_static/locales/tg/LC_MESSAGES/booktheme.mo b/_static/locales/tg/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..b21c6c634 Binary files /dev/null and b/_static/locales/tg/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/tg/LC_MESSAGES/booktheme.po b/_static/locales/tg/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..a92c069a4 --- /dev/null +++ b/_static/locales/tg/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: tg\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Файли манбаъро зеркашӣ кунед" + +msgid "suggest edit" +msgstr "пешниҳод вироиш" + +msgid "Toggle navigation" +msgstr "Гузаришро иваз кунед" + +msgid "open issue" +msgstr "барориши кушод" + +msgid "Download notebook file" +msgstr "Файли дафтарро зеркашӣ кунед" + +msgid "repository" +msgstr "анбор" + +msgid "Theme by the" +msgstr "Мавзӯъи аз" + +msgid "Print to PDF" +msgstr "Чоп ба PDF" + +msgid "Download this page" +msgstr "Ин саҳифаро зеркашӣ кунед" + +msgid "Copyright" +msgstr "Ҳуқуқи муаллиф" + +msgid "Last updated on" +msgstr "Last навсозӣ дар" + +msgid "Launch" +msgstr "Оғоз" + +msgid "Open an issue" +msgstr "Масъаларо кушоед" + +msgid "Fullscreen mode" +msgstr "Ҳолати экрани пурра" + +msgid "Sphinx Book Theme" +msgstr "Сфинкс Мавзӯи китоб" + +msgid "Contents" +msgstr "Мундариҷа" + +msgid "Edit this page" +msgstr "Ин саҳифаро таҳрир кунед" + +msgid "next page" +msgstr "саҳифаи оянда" + +msgid "Source repository" +msgstr "Анбори манбаъ" + +msgid "By" +msgstr "Бо" + +msgid "By the" +msgstr "Бо" + +msgid "previous page" +msgstr "саҳифаи қаблӣ" diff --git a/_static/locales/th/LC_MESSAGES/booktheme.mo b/_static/locales/th/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..abede98aa Binary files /dev/null and b/_static/locales/th/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/th/LC_MESSAGES/booktheme.po b/_static/locales/th/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..25d9837f8 --- /dev/null +++ b/_static/locales/th/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: th\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "ดาวน์โหลดไฟล์ต้นฉบับ" + +msgid "suggest edit" +msgstr "แนะนำแก้ไข" + +msgid "Toggle navigation" +msgstr "ไม่ต้องสลับช่องทาง" + +msgid "open issue" +msgstr "เปิดปัญหา" + +msgid "Download notebook file" +msgstr "ดาวน์โหลดไฟล์สมุดบันทึก" + +msgid "repository" +msgstr "ที่เก็บ" + +msgid "Theme by the" +msgstr "ธีมโดย" + +msgid "Print to PDF" +msgstr "พิมพ์เป็น PDF" + +msgid "Download this page" +msgstr "ดาวน์โหลดหน้านี้" + +msgid "Copyright" +msgstr "ลิขสิทธิ์" + +msgid "Last updated on" +msgstr "ปรับปรุงล่าสุดเมื่อ" + +msgid "Launch" +msgstr "เปิด" + +msgid "Open an issue" +msgstr "เปิดปัญหา" + +msgid "Fullscreen mode" +msgstr "โหมดเต็มหน้าจอ" + +msgid "Sphinx Book Theme" +msgstr "ธีมหนังสือสฟิงซ์" + +msgid "Contents" +msgstr "สารบัญ" + +msgid "Edit this page" +msgstr "แก้ไขหน้านี้" + +msgid "next page" +msgstr "หน้าต่อไป" + +msgid "Source repository" +msgstr "ที่เก็บซอร์ส" + +msgid "By" +msgstr "โดย" + +msgid "By the" +msgstr "โดย" + +msgid "previous page" +msgstr "หน้าที่แล้ว" diff --git a/_static/locales/tl/LC_MESSAGES/booktheme.mo b/_static/locales/tl/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..8df1b7331 Binary files /dev/null and b/_static/locales/tl/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/tl/LC_MESSAGES/booktheme.po b/_static/locales/tl/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..7e28b05fa --- /dev/null +++ b/_static/locales/tl/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: tl\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Mag-download ng file ng pinagmulan" + +msgid "suggest edit" +msgstr "iminumungkahi i-edit" + +msgid "Toggle navigation" +msgstr "I-toggle ang pag-navigate" + +msgid "open issue" +msgstr "bukas na isyu" + +msgid "Download notebook file" +msgstr "Mag-download ng file ng notebook" + +msgid "Theme by the" +msgstr "Tema ng" + +msgid "Print to PDF" +msgstr "I-print sa PDF" + +msgid "Download this page" +msgstr "I-download ang pahinang ito" + +msgid "Copyright" +msgstr "Copyright" + +msgid "Last updated on" +msgstr "Huling na-update noong" + +msgid "Launch" +msgstr "Ilunsad" + +msgid "Open an issue" +msgstr "Magbukas ng isyu" + +msgid "Sphinx Book Theme" +msgstr "Tema ng Sphinx Book" + +msgid "Edit this page" +msgstr "I-edit ang pahinang ito" + +msgid "next page" +msgstr "Susunod na pahina" + +msgid "Source repository" +msgstr "Pinagmulan ng imbakan" + +msgid "By" +msgstr "Ni" + +msgid "By the" +msgstr "Sa pamamagitan ng" + +msgid "previous page" +msgstr "Nakaraang pahina" diff --git a/_static/locales/tr/LC_MESSAGES/booktheme.mo b/_static/locales/tr/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..029ae18af Binary files /dev/null and b/_static/locales/tr/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/tr/LC_MESSAGES/booktheme.po b/_static/locales/tr/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..54d6f5836 --- /dev/null +++ b/_static/locales/tr/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: tr\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Kaynak dosyayı indirin" + +msgid "suggest edit" +msgstr "düzenleme öner" + +msgid "Toggle navigation" +msgstr "Gezinmeyi değiştir" + +msgid "open issue" +msgstr "Açık konu" + +msgid "Download notebook file" +msgstr "Defter dosyasını indirin" + +msgid "repository" +msgstr "depo" + +msgid "Theme by the" +msgstr "Tarafından tema" + +msgid "Print to PDF" +msgstr "PDF olarak yazdır" + +msgid "Download this page" +msgstr "Bu sayfayı indirin" + +msgid "Copyright" +msgstr "Telif hakkı" + +msgid "Last updated on" +msgstr "Son güncelleme tarihi" + +msgid "Launch" +msgstr "Başlatmak" + +msgid "Open an issue" +msgstr "Bir sorunu açın" + +msgid "Fullscreen mode" +msgstr "Tam ekran modu" + +msgid "Sphinx Book Theme" +msgstr "Sfenks Kitap Teması" + +msgid "Contents" +msgstr "İçindekiler" + +msgid "Edit this page" +msgstr "Bu sayfayı düzenle" + +msgid "next page" +msgstr "sonraki Sayfa" + +msgid "Source repository" +msgstr "Kaynak kod deposu" + +msgid "By" +msgstr "Tarafından" + +msgid "By the" +msgstr "Tarafından" + +msgid "previous page" +msgstr "önceki sayfa" diff --git a/_static/locales/uk/LC_MESSAGES/booktheme.mo b/_static/locales/uk/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..16ab78909 Binary files /dev/null and b/_static/locales/uk/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/uk/LC_MESSAGES/booktheme.po b/_static/locales/uk/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..6ecaec679 --- /dev/null +++ b/_static/locales/uk/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: uk\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Завантажити вихідний файл" + +msgid "suggest edit" +msgstr "запропонувати редагувати" + +msgid "Toggle navigation" +msgstr "Переключити навігацію" + +msgid "open issue" +msgstr "відкритий випуск" + +msgid "Download notebook file" +msgstr "Завантажте файл блокнота" + +msgid "repository" +msgstr "сховище" + +msgid "Theme by the" +msgstr "Тема від" + +msgid "Print to PDF" +msgstr "Друк у форматі PDF" + +msgid "Download this page" +msgstr "Завантажте цю сторінку" + +msgid "Copyright" +msgstr "Авторське право" + +msgid "Last updated on" +msgstr "Останнє оновлення:" + +msgid "Launch" +msgstr "Запуск" + +msgid "Open an issue" +msgstr "Відкрийте випуск" + +msgid "Fullscreen mode" +msgstr "Повноекранний режим" + +msgid "Sphinx Book Theme" +msgstr "Тема книги \"Сфінкс\"" + +msgid "Contents" +msgstr "Зміст" + +msgid "Edit this page" +msgstr "Редагувати цю сторінку" + +msgid "next page" +msgstr "Наступна сторінка" + +msgid "Source repository" +msgstr "Джерело сховища" + +msgid "By" +msgstr "Автор" + +msgid "By the" +msgstr "По" + +msgid "previous page" +msgstr "Попередня сторінка" diff --git a/_static/locales/ur/LC_MESSAGES/booktheme.mo b/_static/locales/ur/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..de8c84b93 Binary files /dev/null and b/_static/locales/ur/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/ur/LC_MESSAGES/booktheme.po b/_static/locales/ur/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..818e03de7 --- /dev/null +++ b/_static/locales/ur/LC_MESSAGES/booktheme.po @@ -0,0 +1,66 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: ur\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "سورس فائل ڈاؤن لوڈ کریں" + +msgid "suggest edit" +msgstr "ترمیم کی تجویز کریں" + +msgid "Toggle navigation" +msgstr "نیویگیشن ٹوگل کریں" + +msgid "open issue" +msgstr "کھلا مسئلہ" + +msgid "Download notebook file" +msgstr "نوٹ بک فائل ڈاؤن لوڈ کریں" + +msgid "Theme by the" +msgstr "کے ذریعہ تھیم" + +msgid "Print to PDF" +msgstr "پی ڈی ایف پرنٹ کریں" + +msgid "Download this page" +msgstr "اس صفحے کو ڈاؤن لوڈ کریں" + +msgid "Copyright" +msgstr "کاپی رائٹ" + +msgid "Last updated on" +msgstr "آخری بار تازہ کاری ہوئی" + +msgid "Launch" +msgstr "لانچ کریں" + +msgid "Open an issue" +msgstr "ایک مسئلہ کھولیں" + +msgid "Sphinx Book Theme" +msgstr "سپنکس بک تھیم" + +msgid "Edit this page" +msgstr "اس صفحے میں ترمیم کریں" + +msgid "next page" +msgstr "اگلا صفحہ" + +msgid "Source repository" +msgstr "ماخذ ذخیرہ" + +msgid "By" +msgstr "بذریعہ" + +msgid "By the" +msgstr "کی طرف" + +msgid "previous page" +msgstr "سابقہ ​​صفحہ" diff --git a/_static/locales/vi/LC_MESSAGES/booktheme.mo b/_static/locales/vi/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..2bb32555c Binary files /dev/null and b/_static/locales/vi/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/vi/LC_MESSAGES/booktheme.po b/_static/locales/vi/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..59db26698 --- /dev/null +++ b/_static/locales/vi/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: vi\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "Tải xuống tệp nguồn" + +msgid "suggest edit" +msgstr "đề nghị chỉnh sửa" + +msgid "Toggle navigation" +msgstr "Chuyển đổi điều hướng thành" + +msgid "open issue" +msgstr "vấn đề mở" + +msgid "Download notebook file" +msgstr "Tải xuống tệp sổ tay" + +msgid "repository" +msgstr "kho" + +msgid "Theme by the" +msgstr "Chủ đề của" + +msgid "Print to PDF" +msgstr "In sang PDF" + +msgid "Download this page" +msgstr "Tải xuống trang này" + +msgid "Copyright" +msgstr "Bản quyền" + +msgid "Last updated on" +msgstr "Cập nhật lần cuối vào" + +msgid "Launch" +msgstr "Phóng" + +msgid "Open an issue" +msgstr "Mở một vấn đề" + +msgid "Fullscreen mode" +msgstr "Chế độ toàn màn hình" + +msgid "Sphinx Book Theme" +msgstr "Chủ đề sách nhân sư" + +msgid "Contents" +msgstr "Nội dung" + +msgid "Edit this page" +msgstr "chỉnh sửa trang này" + +msgid "next page" +msgstr "Trang tiếp theo" + +msgid "Source repository" +msgstr "Kho nguồn" + +msgid "By" +msgstr "Bởi" + +msgid "By the" +msgstr "Bằng" + +msgid "previous page" +msgstr "trang trước" diff --git a/_static/locales/zh_CN/LC_MESSAGES/booktheme.mo b/_static/locales/zh_CN/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..0e3235d09 Binary files /dev/null and b/_static/locales/zh_CN/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/zh_CN/LC_MESSAGES/booktheme.po b/_static/locales/zh_CN/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..e8d12dd74 --- /dev/null +++ b/_static/locales/zh_CN/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: zh_CN\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "下载源文件" + +msgid "suggest edit" +msgstr "提出修改建议" + +msgid "Toggle navigation" +msgstr "显示或隐藏导航栏" + +msgid "open issue" +msgstr "创建议题" + +msgid "Download notebook file" +msgstr "下载笔记本文件" + +msgid "repository" +msgstr "仓库" + +msgid "Theme by the" +msgstr "主题作者：" + +msgid "Print to PDF" +msgstr "列印成 PDF" + +msgid "Download this page" +msgstr "下载此页面" + +msgid "Copyright" +msgstr "版权" + +msgid "Last updated on" +msgstr "上次更新时间：" + +msgid "Launch" +msgstr "启动" + +msgid "Open an issue" +msgstr "创建议题" + +msgid "Fullscreen mode" +msgstr "全屏模式" + +msgid "Sphinx Book Theme" +msgstr "Sphinx Book 主题" + +msgid "Contents" +msgstr "目录" + +msgid "Edit this page" +msgstr "编辑此页面" + +msgid "next page" +msgstr "下一页" + +msgid "Source repository" +msgstr "源码库" + +msgid "By" +msgstr "作者：" + +msgid "By the" +msgstr "作者：" + +msgid "previous page" +msgstr "上一页" diff --git a/_static/locales/zh_TW/LC_MESSAGES/booktheme.mo b/_static/locales/zh_TW/LC_MESSAGES/booktheme.mo new file mode 100644 index 000000000..9116fa95d Binary files /dev/null and b/_static/locales/zh_TW/LC_MESSAGES/booktheme.mo differ diff --git a/_static/locales/zh_TW/LC_MESSAGES/booktheme.po b/_static/locales/zh_TW/LC_MESSAGES/booktheme.po new file mode 100644 index 000000000..0ed32f74e --- /dev/null +++ b/_static/locales/zh_TW/LC_MESSAGES/booktheme.po @@ -0,0 +1,75 @@ + +msgid "" +msgstr "" +"Project-Id-Version: Sphinx-Book-Theme\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Language: zh_TW\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +msgid "Download source file" +msgstr "下載原始檔" + +msgid "suggest edit" +msgstr "提出修改建議" + +msgid "Toggle navigation" +msgstr "顯示或隱藏導覽列" + +msgid "open issue" +msgstr "公開的問題" + +msgid "Download notebook file" +msgstr "下載 Notebook 檔案" + +msgid "repository" +msgstr "儲存庫" + +msgid "Theme by the" +msgstr "佈景主題作者：" + +msgid "Print to PDF" +msgstr "列印成 PDF" + +msgid "Download this page" +msgstr "下載此頁面" + +msgid "Copyright" +msgstr "Copyright" + +msgid "Last updated on" +msgstr "最後更新時間：" + +msgid "Launch" +msgstr "啟動" + +msgid "Open an issue" +msgstr "開啟議題" + +msgid "Fullscreen mode" +msgstr "全螢幕模式" + +msgid "Sphinx Book Theme" +msgstr "Sphinx Book 佈景主題" + +msgid "Contents" +msgstr "目錄" + +msgid "Edit this page" +msgstr "編輯此頁面" + +msgid "next page" +msgstr "下一頁" + +msgid "Source repository" +msgstr "來源儲存庫" + +msgid "By" +msgstr "作者：" + +msgid "By the" +msgstr "作者：" + +msgid "previous page" +msgstr "上一頁" diff --git a/_static/minus.png b/_static/minus.png new file mode 100644 index 000000000..d96755fda Binary files /dev/null and b/_static/minus.png differ diff --git a/_static/mystnb.4510f1fc1dee50b3e5859aac5469c37c29e427902b24a333a5f9fcb2f0b3ac41.css b/_static/mystnb.4510f1fc1dee50b3e5859aac5469c37c29e427902b24a333a5f9fcb2f0b3ac41.css new file mode 100644 index 000000000..335663106 --- /dev/null +++ b/_static/mystnb.4510f1fc1dee50b3e5859aac5469c37c29e427902b24a333a5f9fcb2f0b3ac41.css @@ -0,0 +1,2342 @@ +/* Variables */ +:root { + --mystnb-source-bg-color: #f7f7f7; + --mystnb-stdout-bg-color: #fcfcfc; + --mystnb-stderr-bg-color: #fdd; + --mystnb-traceback-bg-color: #fcfcfc; + --mystnb-source-border-color: #ccc; + --mystnb-source-margin-color: green; + --mystnb-stdout-border-color: #f7f7f7; + --mystnb-stderr-border-color: #f7f7f7; + --mystnb-traceback-border-color: #ffd6d6; + --mystnb-hide-prompt-opacity: 70%; + --mystnb-source-border-radius: .4em; + --mystnb-source-border-width: 1px; +} + +/* Whole cell */ +div.container.cell { + padding-left: 0; + margin-bottom: 1em; +} + +/* Removing all background formatting so we can control at the div level */ +.cell_input div.highlight, +.cell_output pre, +.cell_input pre, +.cell_output .output { + border: none; + box-shadow: none; +} + +.cell_output .output pre, +.cell_input pre { + margin: 0px; +} + +/* Input cells */ +div.cell div.cell_input, +div.cell details.above-input>summary { + padding-left: 0em; + padding-right: 0em; + border: var(--mystnb-source-border-width) var(--mystnb-source-border-color) solid; + background-color: var(--mystnb-source-bg-color); + border-left-color: var(--mystnb-source-margin-color); + border-left-width: medium; + border-radius: var(--mystnb-source-border-radius); +} + +div.cell_input>div, +div.cell_output div.output>div.highlight { + margin: 0em !important; + border: none !important; +} + +/* All cell outputs */ +.cell_output { + padding-left: 1em; + padding-right: 0em; + margin-top: 1em; +} + +/* Text outputs from cells */ +.cell_output .output.text_plain, +.cell_output .output.traceback, +.cell_output .output.stream, +.cell_output .output.stderr { + margin-top: 1em; + margin-bottom: 0em; + box-shadow: none; +} + +.cell_output .output.text_plain, +.cell_output .output.stream { + background: var(--mystnb-stdout-bg-color); + border: 1px solid var(--mystnb-stdout-border-color); +} + +.cell_output .output.stderr { + background: var(--mystnb-stderr-bg-color); + border: 1px solid var(--mystnb-stderr-border-color); +} + +.cell_output .output.traceback { + background: var(--mystnb-traceback-bg-color); + border: 1px solid var(--mystnb-traceback-border-color); +} + +/* Collapsible cell content */ +div.cell details.above-input div.cell_input { + border-top-left-radius: 0; + border-top-right-radius: 0; + border-top: var(--mystnb-source-border-width) var(--mystnb-source-border-color) dashed; +} + +div.cell div.cell_input.above-output-prompt { + border-bottom-left-radius: 0; + border-bottom-right-radius: 0; +} + +div.cell details.above-input>summary { + border-bottom-left-radius: 0; + border-bottom-right-radius: 0; + border-bottom: var(--mystnb-source-border-width) var(--mystnb-source-border-color) dashed; + padding-left: 1em; + margin-bottom: 0; +} + +div.cell details.above-output>summary { + background-color: var(--mystnb-source-bg-color); + padding-left: 1em; + padding-right: 0em; + border: var(--mystnb-source-border-width) var(--mystnb-source-border-color) solid; + border-radius: var(--mystnb-source-border-radius); + border-left-color: var(--mystnb-source-margin-color); + border-left-width: medium; +} + +div.cell details.below-input>summary { + background-color: var(--mystnb-source-bg-color); + padding-left: 1em; + padding-right: 0em; + border: var(--mystnb-source-border-width) var(--mystnb-source-border-color) solid; + border-top: none; + border-bottom-left-radius: var(--mystnb-source-border-radius); + border-bottom-right-radius: var(--mystnb-source-border-radius); + border-left-color: var(--mystnb-source-margin-color); + border-left-width: medium; +} + +div.cell details.hide>summary>span { + opacity: var(--mystnb-hide-prompt-opacity); +} + +div.cell details.hide[open]>summary>span.collapsed { + display: none; +} + +div.cell details.hide:not([open])>summary>span.expanded { + display: none; +} + +@keyframes collapsed-fade-in { + 0% { + opacity: 0; + } + + 100% { + opacity: 1; + } +} +div.cell details.hide[open]>summary~* { + -moz-animation: collapsed-fade-in 0.3s ease-in-out; + -webkit-animation: collapsed-fade-in 0.3s ease-in-out; + animation: collapsed-fade-in 0.3s ease-in-out; +} + +/* Math align to the left */ +.cell_output .MathJax_Display { + text-align: left !important; +} + +/* Pandas tables. Pulled from the Jupyter / nbsphinx CSS */ +div.cell_output table { + border: none; + border-collapse: collapse; + border-spacing: 0; + color: black; + font-size: 1em; + table-layout: fixed; +} + +div.cell_output thead { + border-bottom: 1px solid black; + vertical-align: bottom; +} + +div.cell_output tr, +div.cell_output th, +div.cell_output td { + text-align: right; + vertical-align: middle; + padding: 0.5em 0.5em; + line-height: normal; + white-space: normal; + max-width: none; + border: none; +} + +div.cell_output th { + font-weight: bold; +} + +div.cell_output tbody tr:nth-child(odd) { + background: #f5f5f5; +} + +div.cell_output tbody tr:hover { + background: rgba(66, 165, 245, 0.2); +} + +/** source code line numbers **/ +span.linenos { + opacity: 0.5; +} + +/* Inline text from `paste` operation */ + +span.pasted-text { + font-weight: bold; +} + +span.pasted-inline img { + max-height: 2em; +} + +tbody span.pasted-inline img { + max-height: none; +} + +/* Font colors for translated ANSI escape sequences +Color values are copied from Jupyter Notebook +https://github.com/jupyter/notebook/blob/52581f8eda9b319eb0390ac77fe5903c38f81e3e/notebook/static/notebook/less/ansicolors.less#L14-L21 +Background colors from +https://nbsphinx.readthedocs.io/en/latest/code-cells.html#ANSI-Colors +*/ +div.highlight .-Color-Bold { + font-weight: bold; +} + +div.highlight .-Color[class*=-Black] { + color: #3E424D +} + +div.highlight .-Color[class*=-Red] { + color: #E75C58 +} + +div.highlight .-Color[class*=-Green] { + color: #00A250 +} + +div.highlight .-Color[class*=-Yellow] { + color: #DDB62B +} + +div.highlight .-Color[class*=-Blue] { + color: #208FFB +} + +div.highlight .-Color[class*=-Magenta] { + color: #D160C4 +} + +div.highlight .-Color[class*=-Cyan] { + color: #60C6C8 +} + +div.highlight .-Color[class*=-White] { + color: #C5C1B4 +} + +div.highlight .-Color[class*=-BGBlack] { + background-color: #3E424D +} + +div.highlight .-Color[class*=-BGRed] { + background-color: #E75C58 +} + +div.highlight .-Color[class*=-BGGreen] { + background-color: #00A250 +} + +div.highlight .-Color[class*=-BGYellow] { + background-color: #DDB62B +} + +div.highlight .-Color[class*=-BGBlue] { + background-color: #208FFB +} + +div.highlight .-Color[class*=-BGMagenta] { + background-color: #D160C4 +} + +div.highlight .-Color[class*=-BGCyan] { + background-color: #60C6C8 +} + +div.highlight .-Color[class*=-BGWhite] { + background-color: #C5C1B4 +} + +/* Font colors for 8-bit ANSI */ + +div.highlight .-Color[class*=-C0] { + color: #000000 +} + +div.highlight .-Color[class*=-BGC0] { + background-color: #000000 +} + +div.highlight .-Color[class*=-C1] { + color: #800000 +} + +div.highlight .-Color[class*=-BGC1] { + background-color: #800000 +} + +div.highlight .-Color[class*=-C2] { + color: #008000 +} + +div.highlight .-Color[class*=-BGC2] { + background-color: #008000 +} + +div.highlight .-Color[class*=-C3] { + color: #808000 +} + +div.highlight .-Color[class*=-BGC3] { + background-color: #808000 +} + +div.highlight .-Color[class*=-C4] { + color: #000080 +} + +div.highlight .-Color[class*=-BGC4] { + background-color: #000080 +} + +div.highlight .-Color[class*=-C5] { + color: #800080 +} + +div.highlight .-Color[class*=-BGC5] { + background-color: #800080 +} + +div.highlight .-Color[class*=-C6] { + color: #008080 +} + +div.highlight .-Color[class*=-BGC6] { + background-color: #008080 +} + +div.highlight .-Color[class*=-C7] { + color: #C0C0C0 +} + +div.highlight .-Color[class*=-BGC7] { + background-color: #C0C0C0 +} + +div.highlight .-Color[class*=-C8] { + color: #808080 +} + +div.highlight .-Color[class*=-BGC8] { + background-color: #808080 +} + +div.highlight .-Color[class*=-C9] { + color: #FF0000 +} + +div.highlight .-Color[class*=-BGC9] { + background-color: #FF0000 +} + +div.highlight .-Color[class*=-C10] { + color: #00FF00 +} + +div.highlight .-Color[class*=-BGC10] { + background-color: #00FF00 +} + +div.highlight .-Color[class*=-C11] { + color: #FFFF00 +} + +div.highlight .-Color[class*=-BGC11] { + background-color: #FFFF00 +} + +div.highlight .-Color[class*=-C12] { + color: #0000FF +} + +div.highlight .-Color[class*=-BGC12] { + background-color: #0000FF +} + +div.highlight .-Color[class*=-C13] { + color: #FF00FF +} + +div.highlight .-Color[class*=-BGC13] { + background-color: #FF00FF +} + +div.highlight .-Color[class*=-C14] { + color: #00FFFF +} + +div.highlight .-Color[class*=-BGC14] { + background-color: #00FFFF +} + +div.highlight .-Color[class*=-C15] { + color: #FFFFFF +} + +div.highlight .-Color[class*=-BGC15] { + background-color: #FFFFFF +} + +div.highlight .-Color[class*=-C16] { + color: #000000 +} + +div.highlight .-Color[class*=-BGC16] { + background-color: #000000 +} + +div.highlight .-Color[class*=-C17] { + color: #00005F +} + +div.highlight .-Color[class*=-BGC17] { + background-color: #00005F +} + +div.highlight .-Color[class*=-C18] { + color: #000087 +} + +div.highlight .-Color[class*=-BGC18] { + background-color: #000087 +} + +div.highlight .-Color[class*=-C19] { + color: #0000AF +} + +div.highlight .-Color[class*=-BGC19] { + background-color: #0000AF +} + +div.highlight .-Color[class*=-C20] { + color: #0000D7 +} + +div.highlight .-Color[class*=-BGC20] { + background-color: #0000D7 +} + +div.highlight .-Color[class*=-C21] { + color: #0000FF +} + +div.highlight .-Color[class*=-BGC21] { + background-color: #0000FF +} + +div.highlight .-Color[class*=-C22] { + color: #005F00 +} + +div.highlight .-Color[class*=-BGC22] { + background-color: #005F00 +} + +div.highlight .-Color[class*=-C23] { + color: #005F5F +} + +div.highlight .-Color[class*=-BGC23] { + background-color: #005F5F +} + +div.highlight .-Color[class*=-C24] { + color: #005F87 +} + +div.highlight .-Color[class*=-BGC24] { + background-color: #005F87 +} + +div.highlight .-Color[class*=-C25] { + color: #005FAF +} + +div.highlight .-Color[class*=-BGC25] { + background-color: #005FAF +} + +div.highlight .-Color[class*=-C26] { + color: #005FD7 +} + +div.highlight .-Color[class*=-BGC26] { + background-color: #005FD7 +} + +div.highlight .-Color[class*=-C27] { + color: #005FFF +} + +div.highlight .-Color[class*=-BGC27] { + background-color: #005FFF +} + +div.highlight .-Color[class*=-C28] { + color: #008700 +} + +div.highlight .-Color[class*=-BGC28] { + background-color: #008700 +} + +div.highlight .-Color[class*=-C29] { + color: #00875F +} + +div.highlight .-Color[class*=-BGC29] { + background-color: #00875F +} + +div.highlight .-Color[class*=-C30] { + color: #008787 +} + +div.highlight .-Color[class*=-BGC30] { + background-color: #008787 +} + +div.highlight .-Color[class*=-C31] { + color: #0087AF +} + +div.highlight .-Color[class*=-BGC31] { + background-color: #0087AF +} + +div.highlight .-Color[class*=-C32] { + color: #0087D7 +} + +div.highlight .-Color[class*=-BGC32] { + background-color: #0087D7 +} + +div.highlight .-Color[class*=-C33] { + color: #0087FF +} + +div.highlight .-Color[class*=-BGC33] { + background-color: #0087FF +} + +div.highlight .-Color[class*=-C34] { + color: #00AF00 +} + +div.highlight .-Color[class*=-BGC34] { + background-color: #00AF00 +} + +div.highlight .-Color[class*=-C35] { + color: #00AF5F +} + +div.highlight .-Color[class*=-BGC35] { + background-color: #00AF5F +} + +div.highlight .-Color[class*=-C36] { + color: #00AF87 +} + +div.highlight .-Color[class*=-BGC36] { + background-color: #00AF87 +} + +div.highlight .-Color[class*=-C37] { + color: #00AFAF +} + +div.highlight .-Color[class*=-BGC37] { + background-color: #00AFAF +} + +div.highlight .-Color[class*=-C38] { + color: #00AFD7 +} + +div.highlight .-Color[class*=-BGC38] { + background-color: #00AFD7 +} + +div.highlight .-Color[class*=-C39] { + color: #00AFFF +} + +div.highlight .-Color[class*=-BGC39] { + background-color: #00AFFF +} + +div.highlight .-Color[class*=-C40] { + color: #00D700 +} + +div.highlight .-Color[class*=-BGC40] { + background-color: #00D700 +} + +div.highlight .-Color[class*=-C41] { + color: #00D75F +} + +div.highlight .-Color[class*=-BGC41] { + background-color: #00D75F +} + +div.highlight .-Color[class*=-C42] { + color: #00D787 +} + +div.highlight .-Color[class*=-BGC42] { + background-color: #00D787 +} + +div.highlight .-Color[class*=-C43] { + color: #00D7AF +} + +div.highlight .-Color[class*=-BGC43] { + background-color: #00D7AF +} + +div.highlight .-Color[class*=-C44] { + color: #00D7D7 +} + +div.highlight .-Color[class*=-BGC44] { + background-color: #00D7D7 +} + +div.highlight .-Color[class*=-C45] { + color: #00D7FF +} + +div.highlight .-Color[class*=-BGC45] { + background-color: #00D7FF +} + +div.highlight .-Color[class*=-C46] { + color: #00FF00 +} + +div.highlight .-Color[class*=-BGC46] { + background-color: #00FF00 +} + +div.highlight .-Color[class*=-C47] { + color: #00FF5F +} + +div.highlight .-Color[class*=-BGC47] { + background-color: #00FF5F +} + +div.highlight .-Color[class*=-C48] { + color: #00FF87 +} + +div.highlight .-Color[class*=-BGC48] { + background-color: #00FF87 +} + +div.highlight .-Color[class*=-C49] { + color: #00FFAF +} + +div.highlight .-Color[class*=-BGC49] { + background-color: #00FFAF +} + +div.highlight .-Color[class*=-C50] { + color: #00FFD7 +} + +div.highlight .-Color[class*=-BGC50] { + background-color: #00FFD7 +} + +div.highlight .-Color[class*=-C51] { + color: #00FFFF +} + +div.highlight .-Color[class*=-BGC51] { + background-color: #00FFFF +} + +div.highlight .-Color[class*=-C52] { + color: #5F0000 +} + +div.highlight .-Color[class*=-BGC52] { + background-color: #5F0000 +} + +div.highlight .-Color[class*=-C53] { + color: #5F005F +} + +div.highlight .-Color[class*=-BGC53] { + background-color: #5F005F +} + +div.highlight .-Color[class*=-C54] { + color: #5F0087 +} + +div.highlight .-Color[class*=-BGC54] { + background-color: #5F0087 +} + +div.highlight .-Color[class*=-C55] { + color: #5F00AF +} + +div.highlight .-Color[class*=-BGC55] { + background-color: #5F00AF +} + +div.highlight .-Color[class*=-C56] { + color: #5F00D7 +} + +div.highlight .-Color[class*=-BGC56] { + background-color: #5F00D7 +} + +div.highlight .-Color[class*=-C57] { + color: #5F00FF +} + +div.highlight .-Color[class*=-BGC57] { + background-color: #5F00FF +} + +div.highlight .-Color[class*=-C58] { + color: #5F5F00 +} + +div.highlight .-Color[class*=-BGC58] { + background-color: #5F5F00 +} + +div.highlight .-Color[class*=-C59] { + color: #5F5F5F +} + +div.highlight .-Color[class*=-BGC59] { + background-color: #5F5F5F +} + +div.highlight .-Color[class*=-C60] { + color: #5F5F87 +} + +div.highlight .-Color[class*=-BGC60] { + background-color: #5F5F87 +} + +div.highlight .-Color[class*=-C61] { + color: #5F5FAF +} + +div.highlight .-Color[class*=-BGC61] { + background-color: #5F5FAF +} + +div.highlight .-Color[class*=-C62] { + color: #5F5FD7 +} + +div.highlight .-Color[class*=-BGC62] { + background-color: #5F5FD7 +} + +div.highlight .-Color[class*=-C63] { + color: #5F5FFF +} + +div.highlight .-Color[class*=-BGC63] { + background-color: #5F5FFF +} + +div.highlight .-Color[class*=-C64] { + color: #5F8700 +} + +div.highlight .-Color[class*=-BGC64] { + background-color: #5F8700 +} + +div.highlight .-Color[class*=-C65] { + color: #5F875F +} + +div.highlight .-Color[class*=-BGC65] { + background-color: #5F875F +} + +div.highlight .-Color[class*=-C66] { + color: #5F8787 +} + +div.highlight .-Color[class*=-BGC66] { + background-color: #5F8787 +} + +div.highlight .-Color[class*=-C67] { + color: #5F87AF +} + +div.highlight .-Color[class*=-BGC67] { + background-color: #5F87AF +} + +div.highlight .-Color[class*=-C68] { + color: #5F87D7 +} + +div.highlight .-Color[class*=-BGC68] { + background-color: #5F87D7 +} + +div.highlight .-Color[class*=-C69] { + color: #5F87FF +} + +div.highlight .-Color[class*=-BGC69] { + background-color: #5F87FF +} + +div.highlight .-Color[class*=-C70] { + color: #5FAF00 +} + +div.highlight .-Color[class*=-BGC70] { + background-color: #5FAF00 +} + +div.highlight .-Color[class*=-C71] { + color: #5FAF5F +} + +div.highlight .-Color[class*=-BGC71] { + background-color: #5FAF5F +} + +div.highlight .-Color[class*=-C72] { + color: #5FAF87 +} + +div.highlight .-Color[class*=-BGC72] { + background-color: #5FAF87 +} + +div.highlight .-Color[class*=-C73] { + color: #5FAFAF +} + +div.highlight .-Color[class*=-BGC73] { + background-color: #5FAFAF +} + +div.highlight .-Color[class*=-C74] { + color: #5FAFD7 +} + +div.highlight .-Color[class*=-BGC74] { + background-color: #5FAFD7 +} + +div.highlight .-Color[class*=-C75] { + color: #5FAFFF +} + +div.highlight .-Color[class*=-BGC75] { + background-color: #5FAFFF +} + +div.highlight .-Color[class*=-C76] { + color: #5FD700 +} + +div.highlight .-Color[class*=-BGC76] { + background-color: #5FD700 +} + +div.highlight .-Color[class*=-C77] { + color: #5FD75F +} + +div.highlight .-Color[class*=-BGC77] { + background-color: #5FD75F +} + +div.highlight .-Color[class*=-C78] { + color: #5FD787 +} + +div.highlight .-Color[class*=-BGC78] { + background-color: #5FD787 +} + +div.highlight .-Color[class*=-C79] { + color: #5FD7AF +} + +div.highlight .-Color[class*=-BGC79] { + background-color: #5FD7AF +} + +div.highlight .-Color[class*=-C80] { + color: #5FD7D7 +} + +div.highlight .-Color[class*=-BGC80] { + background-color: #5FD7D7 +} + +div.highlight .-Color[class*=-C81] { + color: #5FD7FF +} + +div.highlight .-Color[class*=-BGC81] { + background-color: #5FD7FF +} + +div.highlight .-Color[class*=-C82] { + color: #5FFF00 +} + +div.highlight .-Color[class*=-BGC82] { + background-color: #5FFF00 +} + +div.highlight .-Color[class*=-C83] { + color: #5FFF5F +} + +div.highlight .-Color[class*=-BGC83] { + background-color: #5FFF5F +} + +div.highlight .-Color[class*=-C84] { + color: #5FFF87 +} + +div.highlight .-Color[class*=-BGC84] { + background-color: #5FFF87 +} + +div.highlight .-Color[class*=-C85] { + color: #5FFFAF +} + +div.highlight .-Color[class*=-BGC85] { + background-color: #5FFFAF +} + +div.highlight .-Color[class*=-C86] { + color: #5FFFD7 +} + +div.highlight .-Color[class*=-BGC86] { + background-color: #5FFFD7 +} + +div.highlight .-Color[class*=-C87] { + color: #5FFFFF +} + +div.highlight .-Color[class*=-BGC87] { + background-color: #5FFFFF +} + +div.highlight .-Color[class*=-C88] { + color: #870000 +} + +div.highlight .-Color[class*=-BGC88] { + background-color: #870000 +} + +div.highlight .-Color[class*=-C89] { + color: #87005F +} + +div.highlight .-Color[class*=-BGC89] { + background-color: #87005F +} + +div.highlight .-Color[class*=-C90] { + color: #870087 +} + +div.highlight .-Color[class*=-BGC90] { + background-color: #870087 +} + +div.highlight .-Color[class*=-C91] { + color: #8700AF +} + +div.highlight .-Color[class*=-BGC91] { + background-color: #8700AF +} + +div.highlight .-Color[class*=-C92] { + color: #8700D7 +} + +div.highlight .-Color[class*=-BGC92] { + background-color: #8700D7 +} + +div.highlight .-Color[class*=-C93] { + color: #8700FF +} + +div.highlight .-Color[class*=-BGC93] { + background-color: #8700FF +} + +div.highlight .-Color[class*=-C94] { + color: #875F00 +} + +div.highlight .-Color[class*=-BGC94] { + background-color: #875F00 +} + +div.highlight .-Color[class*=-C95] { + color: #875F5F +} + +div.highlight .-Color[class*=-BGC95] { + background-color: #875F5F +} + +div.highlight .-Color[class*=-C96] { + color: #875F87 +} + +div.highlight .-Color[class*=-BGC96] { + background-color: #875F87 +} + +div.highlight .-Color[class*=-C97] { + color: #875FAF +} + +div.highlight .-Color[class*=-BGC97] { + background-color: #875FAF +} + +div.highlight .-Color[class*=-C98] { + color: #875FD7 +} + +div.highlight .-Color[class*=-BGC98] { + background-color: #875FD7 +} + +div.highlight .-Color[class*=-C99] { + color: #875FFF +} + +div.highlight .-Color[class*=-BGC99] { + background-color: #875FFF +} + +div.highlight .-Color[class*=-C100] { + color: #878700 +} + +div.highlight .-Color[class*=-BGC100] { + background-color: #878700 +} + +div.highlight .-Color[class*=-C101] { + color: #87875F +} + +div.highlight .-Color[class*=-BGC101] { + background-color: #87875F +} + +div.highlight .-Color[class*=-C102] { + color: #878787 +} + +div.highlight .-Color[class*=-BGC102] { + background-color: #878787 +} + +div.highlight .-Color[class*=-C103] { + color: #8787AF +} + +div.highlight .-Color[class*=-BGC103] { + background-color: #8787AF +} + +div.highlight .-Color[class*=-C104] { + color: #8787D7 +} + +div.highlight .-Color[class*=-BGC104] { + background-color: #8787D7 +} + +div.highlight .-Color[class*=-C105] { + color: #8787FF +} + +div.highlight .-Color[class*=-BGC105] { + background-color: #8787FF +} + +div.highlight .-Color[class*=-C106] { + color: #87AF00 +} + +div.highlight .-Color[class*=-BGC106] { + background-color: #87AF00 +} + +div.highlight .-Color[class*=-C107] { + color: #87AF5F +} + +div.highlight .-Color[class*=-BGC107] { + background-color: #87AF5F +} + +div.highlight .-Color[class*=-C108] { + color: #87AF87 +} + +div.highlight .-Color[class*=-BGC108] { + background-color: #87AF87 +} + +div.highlight .-Color[class*=-C109] { + color: #87AFAF +} + +div.highlight .-Color[class*=-BGC109] { + background-color: #87AFAF +} + +div.highlight .-Color[class*=-C110] { + color: #87AFD7 +} + +div.highlight .-Color[class*=-BGC110] { + background-color: #87AFD7 +} + +div.highlight .-Color[class*=-C111] { + color: #87AFFF +} + +div.highlight .-Color[class*=-BGC111] { + background-color: #87AFFF +} + +div.highlight .-Color[class*=-C112] { + color: #87D700 +} + +div.highlight .-Color[class*=-BGC112] { + background-color: #87D700 +} + +div.highlight .-Color[class*=-C113] { + color: #87D75F +} + +div.highlight .-Color[class*=-BGC113] { + background-color: #87D75F +} + +div.highlight .-Color[class*=-C114] { + color: #87D787 +} + +div.highlight .-Color[class*=-BGC114] { + background-color: #87D787 +} + +div.highlight .-Color[class*=-C115] { + color: #87D7AF +} + +div.highlight .-Color[class*=-BGC115] { + background-color: #87D7AF +} + +div.highlight .-Color[class*=-C116] { + color: #87D7D7 +} + +div.highlight .-Color[class*=-BGC116] { + background-color: #87D7D7 +} + +div.highlight .-Color[class*=-C117] { + color: #87D7FF +} + +div.highlight .-Color[class*=-BGC117] { + background-color: #87D7FF +} + +div.highlight .-Color[class*=-C118] { + color: #87FF00 +} + +div.highlight .-Color[class*=-BGC118] { + background-color: #87FF00 +} + +div.highlight .-Color[class*=-C119] { + color: #87FF5F +} + +div.highlight .-Color[class*=-BGC119] { + background-color: #87FF5F +} + +div.highlight .-Color[class*=-C120] { + color: #87FF87 +} + +div.highlight .-Color[class*=-BGC120] { + background-color: #87FF87 +} + +div.highlight .-Color[class*=-C121] { + color: #87FFAF +} + +div.highlight .-Color[class*=-BGC121] { + background-color: #87FFAF +} + +div.highlight .-Color[class*=-C122] { + color: #87FFD7 +} + +div.highlight .-Color[class*=-BGC122] { + background-color: #87FFD7 +} + +div.highlight .-Color[class*=-C123] { + color: #87FFFF +} + +div.highlight .-Color[class*=-BGC123] { + background-color: #87FFFF +} + +div.highlight .-Color[class*=-C124] { + color: #AF0000 +} + +div.highlight .-Color[class*=-BGC124] { + background-color: #AF0000 +} + +div.highlight .-Color[class*=-C125] { + color: #AF005F +} + +div.highlight .-Color[class*=-BGC125] { + background-color: #AF005F +} + +div.highlight .-Color[class*=-C126] { + color: #AF0087 +} + +div.highlight .-Color[class*=-BGC126] { + background-color: #AF0087 +} + +div.highlight .-Color[class*=-C127] { + color: #AF00AF +} + +div.highlight .-Color[class*=-BGC127] { + background-color: #AF00AF +} + +div.highlight .-Color[class*=-C128] { + color: #AF00D7 +} + +div.highlight .-Color[class*=-BGC128] { + background-color: #AF00D7 +} + +div.highlight .-Color[class*=-C129] { + color: #AF00FF +} + +div.highlight .-Color[class*=-BGC129] { + background-color: #AF00FF +} + +div.highlight .-Color[class*=-C130] { + color: #AF5F00 +} + +div.highlight .-Color[class*=-BGC130] { + background-color: #AF5F00 +} + +div.highlight .-Color[class*=-C131] { + color: #AF5F5F +} + +div.highlight .-Color[class*=-BGC131] { + background-color: #AF5F5F +} + +div.highlight .-Color[class*=-C132] { + color: #AF5F87 +} + +div.highlight .-Color[class*=-BGC132] { + background-color: #AF5F87 +} + +div.highlight .-Color[class*=-C133] { + color: #AF5FAF +} + +div.highlight .-Color[class*=-BGC133] { + background-color: #AF5FAF +} + +div.highlight .-Color[class*=-C134] { + color: #AF5FD7 +} + +div.highlight .-Color[class*=-BGC134] { + background-color: #AF5FD7 +} + +div.highlight .-Color[class*=-C135] { + color: #AF5FFF +} + +div.highlight .-Color[class*=-BGC135] { + background-color: #AF5FFF +} + +div.highlight .-Color[class*=-C136] { + color: #AF8700 +} + +div.highlight .-Color[class*=-BGC136] { + background-color: #AF8700 +} + +div.highlight .-Color[class*=-C137] { + color: #AF875F +} + +div.highlight .-Color[class*=-BGC137] { + background-color: #AF875F +} + +div.highlight .-Color[class*=-C138] { + color: #AF8787 +} + +div.highlight .-Color[class*=-BGC138] { + background-color: #AF8787 +} + +div.highlight .-Color[class*=-C139] { + color: #AF87AF +} + +div.highlight .-Color[class*=-BGC139] { + background-color: #AF87AF +} + +div.highlight .-Color[class*=-C140] { + color: #AF87D7 +} + +div.highlight .-Color[class*=-BGC140] { + background-color: #AF87D7 +} + +div.highlight .-Color[class*=-C141] { + color: #AF87FF +} + +div.highlight .-Color[class*=-BGC141] { + background-color: #AF87FF +} + +div.highlight .-Color[class*=-C142] { + color: #AFAF00 +} + +div.highlight .-Color[class*=-BGC142] { + background-color: #AFAF00 +} + +div.highlight .-Color[class*=-C143] { + color: #AFAF5F +} + +div.highlight .-Color[class*=-BGC143] { + background-color: #AFAF5F +} + +div.highlight .-Color[class*=-C144] { + color: #AFAF87 +} + +div.highlight .-Color[class*=-BGC144] { + background-color: #AFAF87 +} + +div.highlight .-Color[class*=-C145] { + color: #AFAFAF +} + +div.highlight .-Color[class*=-BGC145] { + background-color: #AFAFAF +} + +div.highlight .-Color[class*=-C146] { + color: #AFAFD7 +} + +div.highlight .-Color[class*=-BGC146] { + background-color: #AFAFD7 +} + +div.highlight .-Color[class*=-C147] { + color: #AFAFFF +} + +div.highlight .-Color[class*=-BGC147] { + background-color: #AFAFFF +} + +div.highlight .-Color[class*=-C148] { + color: #AFD700 +} + +div.highlight .-Color[class*=-BGC148] { + background-color: #AFD700 +} + +div.highlight .-Color[class*=-C149] { + color: #AFD75F +} + +div.highlight .-Color[class*=-BGC149] { + background-color: #AFD75F +} + +div.highlight .-Color[class*=-C150] { + color: #AFD787 +} + +div.highlight .-Color[class*=-BGC150] { + background-color: #AFD787 +} + +div.highlight .-Color[class*=-C151] { + color: #AFD7AF +} + +div.highlight .-Color[class*=-BGC151] { + background-color: #AFD7AF +} + +div.highlight .-Color[class*=-C152] { + color: #AFD7D7 +} + +div.highlight .-Color[class*=-BGC152] { + background-color: #AFD7D7 +} + +div.highlight .-Color[class*=-C153] { + color: #AFD7FF +} + +div.highlight .-Color[class*=-BGC153] { + background-color: #AFD7FF +} + +div.highlight .-Color[class*=-C154] { + color: #AFFF00 +} + +div.highlight .-Color[class*=-BGC154] { + background-color: #AFFF00 +} + +div.highlight .-Color[class*=-C155] { + color: #AFFF5F +} + +div.highlight .-Color[class*=-BGC155] { + background-color: #AFFF5F +} + +div.highlight .-Color[class*=-C156] { + color: #AFFF87 +} + +div.highlight .-Color[class*=-BGC156] { + background-color: #AFFF87 +} + +div.highlight .-Color[class*=-C157] { + color: #AFFFAF +} + +div.highlight .-Color[class*=-BGC157] { + background-color: #AFFFAF +} + +div.highlight .-Color[class*=-C158] { + color: #AFFFD7 +} + +div.highlight .-Color[class*=-BGC158] { + background-color: #AFFFD7 +} + +div.highlight .-Color[class*=-C159] { + color: #AFFFFF +} + +div.highlight .-Color[class*=-BGC159] { + background-color: #AFFFFF +} + +div.highlight .-Color[class*=-C160] { + color: #D70000 +} + +div.highlight .-Color[class*=-BGC160] { + background-color: #D70000 +} + +div.highlight .-Color[class*=-C161] { + color: #D7005F +} + +div.highlight .-Color[class*=-BGC161] { + background-color: #D7005F +} + +div.highlight .-Color[class*=-C162] { + color: #D70087 +} + +div.highlight .-Color[class*=-BGC162] { + background-color: #D70087 +} + +div.highlight .-Color[class*=-C163] { + color: #D700AF +} + +div.highlight .-Color[class*=-BGC163] { + background-color: #D700AF +} + +div.highlight .-Color[class*=-C164] { + color: #D700D7 +} + +div.highlight .-Color[class*=-BGC164] { + background-color: #D700D7 +} + +div.highlight .-Color[class*=-C165] { + color: #D700FF +} + +div.highlight .-Color[class*=-BGC165] { + background-color: #D700FF +} + +div.highlight .-Color[class*=-C166] { + color: #D75F00 +} + +div.highlight .-Color[class*=-BGC166] { + background-color: #D75F00 +} + +div.highlight .-Color[class*=-C167] { + color: #D75F5F +} + +div.highlight .-Color[class*=-BGC167] { + background-color: #D75F5F +} + +div.highlight .-Color[class*=-C168] { + color: #D75F87 +} + +div.highlight .-Color[class*=-BGC168] { + background-color: #D75F87 +} + +div.highlight .-Color[class*=-C169] { + color: #D75FAF +} + +div.highlight .-Color[class*=-BGC169] { + background-color: #D75FAF +} + +div.highlight .-Color[class*=-C170] { + color: #D75FD7 +} + +div.highlight .-Color[class*=-BGC170] { + background-color: #D75FD7 +} + +div.highlight .-Color[class*=-C171] { + color: #D75FFF +} + +div.highlight .-Color[class*=-BGC171] { + background-color: #D75FFF +} + +div.highlight .-Color[class*=-C172] { + color: #D78700 +} + +div.highlight .-Color[class*=-BGC172] { + background-color: #D78700 +} + +div.highlight .-Color[class*=-C173] { + color: #D7875F +} + +div.highlight .-Color[class*=-BGC173] { + background-color: #D7875F +} + +div.highlight .-Color[class*=-C174] { + color: #D78787 +} + +div.highlight .-Color[class*=-BGC174] { + background-color: #D78787 +} + +div.highlight .-Color[class*=-C175] { + color: #D787AF +} + +div.highlight .-Color[class*=-BGC175] { + background-color: #D787AF +} + +div.highlight .-Color[class*=-C176] { + color: #D787D7 +} + +div.highlight .-Color[class*=-BGC176] { + background-color: #D787D7 +} + +div.highlight .-Color[class*=-C177] { + color: #D787FF +} + +div.highlight .-Color[class*=-BGC177] { + background-color: #D787FF +} + +div.highlight .-Color[class*=-C178] { + color: #D7AF00 +} + +div.highlight .-Color[class*=-BGC178] { + background-color: #D7AF00 +} + +div.highlight .-Color[class*=-C179] { + color: #D7AF5F +} + +div.highlight .-Color[class*=-BGC179] { + background-color: #D7AF5F +} + +div.highlight .-Color[class*=-C180] { + color: #D7AF87 +} + +div.highlight .-Color[class*=-BGC180] { + background-color: #D7AF87 +} + +div.highlight .-Color[class*=-C181] { + color: #D7AFAF +} + +div.highlight .-Color[class*=-BGC181] { + background-color: #D7AFAF +} + +div.highlight .-Color[class*=-C182] { + color: #D7AFD7 +} + +div.highlight .-Color[class*=-BGC182] { + background-color: #D7AFD7 +} + +div.highlight .-Color[class*=-C183] { + color: #D7AFFF +} + +div.highlight .-Color[class*=-BGC183] { + background-color: #D7AFFF +} + +div.highlight .-Color[class*=-C184] { + color: #D7D700 +} + +div.highlight .-Color[class*=-BGC184] { + background-color: #D7D700 +} + +div.highlight .-Color[class*=-C185] { + color: #D7D75F +} + +div.highlight .-Color[class*=-BGC185] { + background-color: #D7D75F +} + +div.highlight .-Color[class*=-C186] { + color: #D7D787 +} + +div.highlight .-Color[class*=-BGC186] { + background-color: #D7D787 +} + +div.highlight .-Color[class*=-C187] { + color: #D7D7AF +} + +div.highlight .-Color[class*=-BGC187] { + background-color: #D7D7AF +} + +div.highlight .-Color[class*=-C188] { + color: #D7D7D7 +} + +div.highlight .-Color[class*=-BGC188] { + background-color: #D7D7D7 +} + +div.highlight .-Color[class*=-C189] { + color: #D7D7FF +} + +div.highlight .-Color[class*=-BGC189] { + background-color: #D7D7FF +} + +div.highlight .-Color[class*=-C190] { + color: #D7FF00 +} + +div.highlight .-Color[class*=-BGC190] { + background-color: #D7FF00 +} + +div.highlight .-Color[class*=-C191] { + color: #D7FF5F +} + +div.highlight .-Color[class*=-BGC191] { + background-color: #D7FF5F +} + +div.highlight .-Color[class*=-C192] { + color: #D7FF87 +} + +div.highlight .-Color[class*=-BGC192] { + background-color: #D7FF87 +} + +div.highlight .-Color[class*=-C193] { + color: #D7FFAF +} + +div.highlight .-Color[class*=-BGC193] { + background-color: #D7FFAF +} + +div.highlight .-Color[class*=-C194] { + color: #D7FFD7 +} + +div.highlight .-Color[class*=-BGC194] { + background-color: #D7FFD7 +} + +div.highlight .-Color[class*=-C195] { + color: #D7FFFF +} + +div.highlight .-Color[class*=-BGC195] { + background-color: #D7FFFF +} + +div.highlight .-Color[class*=-C196] { + color: #FF0000 +} + +div.highlight .-Color[class*=-BGC196] { + background-color: #FF0000 +} + +div.highlight .-Color[class*=-C197] { + color: #FF005F +} + +div.highlight .-Color[class*=-BGC197] { + background-color: #FF005F +} + +div.highlight .-Color[class*=-C198] { + color: #FF0087 +} + +div.highlight .-Color[class*=-BGC198] { + background-color: #FF0087 +} + +div.highlight .-Color[class*=-C199] { + color: #FF00AF +} + +div.highlight .-Color[class*=-BGC199] { + background-color: #FF00AF +} + +div.highlight .-Color[class*=-C200] { + color: #FF00D7 +} + +div.highlight .-Color[class*=-BGC200] { + background-color: #FF00D7 +} + +div.highlight .-Color[class*=-C201] { + color: #FF00FF +} + +div.highlight .-Color[class*=-BGC201] { + background-color: #FF00FF +} + +div.highlight .-Color[class*=-C202] { + color: #FF5F00 +} + +div.highlight .-Color[class*=-BGC202] { + background-color: #FF5F00 +} + +div.highlight .-Color[class*=-C203] { + color: #FF5F5F +} + +div.highlight .-Color[class*=-BGC203] { + background-color: #FF5F5F +} + +div.highlight .-Color[class*=-C204] { + color: #FF5F87 +} + +div.highlight .-Color[class*=-BGC204] { + background-color: #FF5F87 +} + +div.highlight .-Color[class*=-C205] { + color: #FF5FAF +} + +div.highlight .-Color[class*=-BGC205] { + background-color: #FF5FAF +} + +div.highlight .-Color[class*=-C206] { + color: #FF5FD7 +} + +div.highlight .-Color[class*=-BGC206] { + background-color: #FF5FD7 +} + +div.highlight .-Color[class*=-C207] { + color: #FF5FFF +} + +div.highlight .-Color[class*=-BGC207] { + background-color: #FF5FFF +} + +div.highlight .-Color[class*=-C208] { + color: #FF8700 +} + +div.highlight .-Color[class*=-BGC208] { + background-color: #FF8700 +} + +div.highlight .-Color[class*=-C209] { + color: #FF875F +} + +div.highlight .-Color[class*=-BGC209] { + background-color: #FF875F +} + +div.highlight .-Color[class*=-C210] { + color: #FF8787 +} + +div.highlight .-Color[class*=-BGC210] { + background-color: #FF8787 +} + +div.highlight .-Color[class*=-C211] { + color: #FF87AF +} + +div.highlight .-Color[class*=-BGC211] { + background-color: #FF87AF +} + +div.highlight .-Color[class*=-C212] { + color: #FF87D7 +} + +div.highlight .-Color[class*=-BGC212] { + background-color: #FF87D7 +} + +div.highlight .-Color[class*=-C213] { + color: #FF87FF +} + +div.highlight .-Color[class*=-BGC213] { + background-color: #FF87FF +} + +div.highlight .-Color[class*=-C214] { + color: #FFAF00 +} + +div.highlight .-Color[class*=-BGC214] { + background-color: #FFAF00 +} + +div.highlight .-Color[class*=-C215] { + color: #FFAF5F +} + +div.highlight .-Color[class*=-BGC215] { + background-color: #FFAF5F +} + +div.highlight .-Color[class*=-C216] { + color: #FFAF87 +} + +div.highlight .-Color[class*=-BGC216] { + background-color: #FFAF87 +} + +div.highlight .-Color[class*=-C217] { + color: #FFAFAF +} + +div.highlight .-Color[class*=-BGC217] { + background-color: #FFAFAF +} + +div.highlight .-Color[class*=-C218] { + color: #FFAFD7 +} + +div.highlight .-Color[class*=-BGC218] { + background-color: #FFAFD7 +} + +div.highlight .-Color[class*=-C219] { + color: #FFAFFF +} + +div.highlight .-Color[class*=-BGC219] { + background-color: #FFAFFF +} + +div.highlight .-Color[class*=-C220] { + color: #FFD700 +} + +div.highlight .-Color[class*=-BGC220] { + background-color: #FFD700 +} + +div.highlight .-Color[class*=-C221] { + color: #FFD75F +} + +div.highlight .-Color[class*=-BGC221] { + background-color: #FFD75F +} + +div.highlight .-Color[class*=-C222] { + color: #FFD787 +} + +div.highlight .-Color[class*=-BGC222] { + background-color: #FFD787 +} + +div.highlight .-Color[class*=-C223] { + color: #FFD7AF +} + +div.highlight .-Color[class*=-BGC223] { + background-color: #FFD7AF +} + +div.highlight .-Color[class*=-C224] { + color: #FFD7D7 +} + +div.highlight .-Color[class*=-BGC224] { + background-color: #FFD7D7 +} + +div.highlight .-Color[class*=-C225] { + color: #FFD7FF +} + +div.highlight .-Color[class*=-BGC225] { + background-color: #FFD7FF +} + +div.highlight .-Color[class*=-C226] { + color: #FFFF00 +} + +div.highlight .-Color[class*=-BGC226] { + background-color: #FFFF00 +} + +div.highlight .-Color[class*=-C227] { + color: #FFFF5F +} + +div.highlight .-Color[class*=-BGC227] { + background-color: #FFFF5F +} + +div.highlight .-Color[class*=-C228] { + color: #FFFF87 +} + +div.highlight .-Color[class*=-BGC228] { + background-color: #FFFF87 +} + +div.highlight .-Color[class*=-C229] { + color: #FFFFAF +} + +div.highlight .-Color[class*=-BGC229] { + background-color: #FFFFAF +} + +div.highlight .-Color[class*=-C230] { + color: #FFFFD7 +} + +div.highlight .-Color[class*=-BGC230] { + background-color: #FFFFD7 +} + +div.highlight .-Color[class*=-C231] { + color: #FFFFFF +} + +div.highlight .-Color[class*=-BGC231] { + background-color: #FFFFFF +} + +div.highlight .-Color[class*=-C232] { + color: #080808 +} + +div.highlight .-Color[class*=-BGC232] { + background-color: #080808 +} + +div.highlight .-Color[class*=-C233] { + color: #121212 +} + +div.highlight .-Color[class*=-BGC233] { + background-color: #121212 +} + +div.highlight .-Color[class*=-C234] { + color: #1C1C1C +} + +div.highlight .-Color[class*=-BGC234] { + background-color: #1C1C1C +} + +div.highlight .-Color[class*=-C235] { + color: #262626 +} + +div.highlight .-Color[class*=-BGC235] { + background-color: #262626 +} + +div.highlight .-Color[class*=-C236] { + color: #303030 +} + +div.highlight .-Color[class*=-BGC236] { + background-color: #303030 +} + +div.highlight .-Color[class*=-C237] { + color: #3A3A3A +} + +div.highlight .-Color[class*=-BGC237] { + background-color: #3A3A3A +} + +div.highlight .-Color[class*=-C238] { + color: #444444 +} + +div.highlight .-Color[class*=-BGC238] { + background-color: #444444 +} + +div.highlight .-Color[class*=-C239] { + color: #4E4E4E +} + +div.highlight .-Color[class*=-BGC239] { + background-color: #4E4E4E +} + +div.highlight .-Color[class*=-C240] { + color: #585858 +} + +div.highlight .-Color[class*=-BGC240] { + background-color: #585858 +} + +div.highlight .-Color[class*=-C241] { + color: #626262 +} + +div.highlight .-Color[class*=-BGC241] { + background-color: #626262 +} + +div.highlight .-Color[class*=-C242] { + color: #6C6C6C +} + +div.highlight .-Color[class*=-BGC242] { + background-color: #6C6C6C +} + +div.highlight .-Color[class*=-C243] { + color: #767676 +} + +div.highlight .-Color[class*=-BGC243] { + background-color: #767676 +} + +div.highlight .-Color[class*=-C244] { + color: #808080 +} + +div.highlight .-Color[class*=-BGC244] { + background-color: #808080 +} + +div.highlight .-Color[class*=-C245] { + color: #8A8A8A +} + +div.highlight .-Color[class*=-BGC245] { + background-color: #8A8A8A +} + +div.highlight .-Color[class*=-C246] { + color: #949494 +} + +div.highlight .-Color[class*=-BGC246] { + background-color: #949494 +} + +div.highlight .-Color[class*=-C247] { + color: #9E9E9E +} + +div.highlight .-Color[class*=-BGC247] { + background-color: #9E9E9E +} + +div.highlight .-Color[class*=-C248] { + color: #A8A8A8 +} + +div.highlight .-Color[class*=-BGC248] { + background-color: #A8A8A8 +} + +div.highlight .-Color[class*=-C249] { + color: #B2B2B2 +} + +div.highlight .-Color[class*=-BGC249] { + background-color: #B2B2B2 +} + +div.highlight .-Color[class*=-C250] { + color: #BCBCBC +} + +div.highlight .-Color[class*=-BGC250] { + background-color: #BCBCBC +} + +div.highlight .-Color[class*=-C251] { + color: #C6C6C6 +} + +div.highlight .-Color[class*=-BGC251] { + background-color: #C6C6C6 +} + +div.highlight .-Color[class*=-C252] { + color: #D0D0D0 +} + +div.highlight .-Color[class*=-BGC252] { + background-color: #D0D0D0 +} + +div.highlight .-Color[class*=-C253] { + color: #DADADA +} + +div.highlight .-Color[class*=-BGC253] { + background-color: #DADADA +} + +div.highlight .-Color[class*=-C254] { + color: #E4E4E4 +} + +div.highlight .-Color[class*=-BGC254] { + background-color: #E4E4E4 +} + +div.highlight .-Color[class*=-C255] { + color: #EEEEEE +} + +div.highlight .-Color[class*=-BGC255] { + background-color: #EEEEEE +} diff --git a/_static/play-solid.svg b/_static/play-solid.svg new file mode 100644 index 000000000..bcd81f7a6 --- /dev/null +++ b/_static/play-solid.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/_static/plus.png b/_static/plus.png new file mode 100644 index 000000000..7107cec93 Binary files /dev/null and b/_static/plus.png differ diff --git a/_static/pygments.css b/_static/pygments.css new file mode 100644 index 000000000..997797f27 --- /dev/null +++ b/_static/pygments.css @@ -0,0 +1,152 @@ +html[data-theme="light"] .highlight pre { line-height: 125%; } +html[data-theme="light"] .highlight td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +html[data-theme="light"] .highlight span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +html[data-theme="light"] .highlight td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +html[data-theme="light"] .highlight span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +html[data-theme="light"] .highlight .hll { background-color: #7971292e } +html[data-theme="light"] .highlight { background: #fefefe; color: #545454 } +html[data-theme="light"] .highlight .c { color: #797129 } /* Comment */ +html[data-theme="light"] .highlight .err { color: #d91e18 } /* Error */ +html[data-theme="light"] .highlight .k { color: #7928a1 } /* Keyword */ +html[data-theme="light"] .highlight .l { color: #797129 } /* Literal */ +html[data-theme="light"] .highlight .n { color: #545454 } /* Name */ +html[data-theme="light"] .highlight .o { color: #008000 } /* Operator */ +html[data-theme="light"] .highlight .p { color: #545454 } /* Punctuation */ +html[data-theme="light"] .highlight .ch { color: #797129 } /* Comment.Hashbang */ +html[data-theme="light"] .highlight .cm { color: #797129 } /* Comment.Multiline */ +html[data-theme="light"] .highlight .cp { color: #797129 } /* Comment.Preproc */ +html[data-theme="light"] .highlight .cpf { color: #797129 } /* Comment.PreprocFile */ +html[data-theme="light"] .highlight .c1 { color: #797129 } /* Comment.Single */ +html[data-theme="light"] .highlight .cs { color: #797129 } /* Comment.Special */ +html[data-theme="light"] .highlight .gd { color: #007faa } /* Generic.Deleted */ +html[data-theme="light"] .highlight .ge { font-style: italic } /* Generic.Emph */ +html[data-theme="light"] .highlight .gh { color: #007faa } /* Generic.Heading */ +html[data-theme="light"] .highlight .gs { font-weight: bold } /* Generic.Strong */ +html[data-theme="light"] .highlight .gu { color: #007faa } /* Generic.Subheading */ +html[data-theme="light"] .highlight .kc { color: #7928a1 } /* Keyword.Constant */ +html[data-theme="light"] .highlight .kd { color: #7928a1 } /* Keyword.Declaration */ +html[data-theme="light"] .highlight .kn { color: #7928a1 } /* Keyword.Namespace */ +html[data-theme="light"] .highlight .kp { color: #7928a1 } /* Keyword.Pseudo */ +html[data-theme="light"] .highlight .kr { color: #7928a1 } /* Keyword.Reserved */ +html[data-theme="light"] .highlight .kt { color: #797129 } /* Keyword.Type */ +html[data-theme="light"] .highlight .ld { color: #797129 } /* Literal.Date */ +html[data-theme="light"] .highlight .m { color: #797129 } /* Literal.Number */ +html[data-theme="light"] .highlight .s { color: #008000 } /* Literal.String */ +html[data-theme="light"] .highlight .na { color: #797129 } /* Name.Attribute */ +html[data-theme="light"] .highlight .nb { color: #797129 } /* Name.Builtin */ +html[data-theme="light"] .highlight .nc { color: #007faa } /* Name.Class */ +html[data-theme="light"] .highlight .no { color: #007faa } /* Name.Constant */ +html[data-theme="light"] .highlight .nd { color: #797129 } /* Name.Decorator */ +html[data-theme="light"] .highlight .ni { color: #008000 } /* Name.Entity */ +html[data-theme="light"] .highlight .ne { color: #7928a1 } /* Name.Exception */ +html[data-theme="light"] .highlight .nf { color: #007faa } /* Name.Function */ +html[data-theme="light"] .highlight .nl { color: #797129 } /* Name.Label */ +html[data-theme="light"] .highlight .nn { color: #545454 } /* Name.Namespace */ +html[data-theme="light"] .highlight .nx { color: #545454 } /* Name.Other */ +html[data-theme="light"] .highlight .py { color: #007faa } /* Name.Property */ +html[data-theme="light"] .highlight .nt { color: #007faa } /* Name.Tag */ +html[data-theme="light"] .highlight .nv { color: #d91e18 } /* Name.Variable */ +html[data-theme="light"] .highlight .ow { color: #7928a1 } /* Operator.Word */ +html[data-theme="light"] .highlight .pm { color: #545454 } /* Punctuation.Marker */ +html[data-theme="light"] .highlight .w { color: #545454 } /* Text.Whitespace */ +html[data-theme="light"] .highlight .mb { color: #797129 } /* Literal.Number.Bin */ +html[data-theme="light"] .highlight .mf { color: #797129 } /* Literal.Number.Float */ +html[data-theme="light"] .highlight .mh { color: #797129 } /* Literal.Number.Hex */ +html[data-theme="light"] .highlight .mi { color: #797129 } /* Literal.Number.Integer */ +html[data-theme="light"] .highlight .mo { color: #797129 } /* Literal.Number.Oct */ +html[data-theme="light"] .highlight .sa { color: #008000 } /* Literal.String.Affix */ +html[data-theme="light"] .highlight .sb { color: #008000 } /* Literal.String.Backtick */ +html[data-theme="light"] .highlight .sc { color: #008000 } /* Literal.String.Char */ +html[data-theme="light"] .highlight .dl { color: #008000 } /* Literal.String.Delimiter */ +html[data-theme="light"] .highlight .sd { color: #008000 } /* Literal.String.Doc */ +html[data-theme="light"] .highlight .s2 { color: #008000 } /* Literal.String.Double */ +html[data-theme="light"] .highlight .se { color: #008000 } /* Literal.String.Escape */ +html[data-theme="light"] .highlight .sh { color: #008000 } /* Literal.String.Heredoc */ +html[data-theme="light"] .highlight .si { color: #008000 } /* Literal.String.Interpol */ +html[data-theme="light"] .highlight .sx { color: #008000 } /* Literal.String.Other */ +html[data-theme="light"] .highlight .sr { color: #d91e18 } /* Literal.String.Regex */ +html[data-theme="light"] .highlight .s1 { color: #008000 } /* Literal.String.Single */ +html[data-theme="light"] .highlight .ss { color: #007faa } /* Literal.String.Symbol */ +html[data-theme="light"] .highlight .bp { color: #797129 } /* Name.Builtin.Pseudo */ +html[data-theme="light"] .highlight .fm { color: #007faa } /* Name.Function.Magic */ +html[data-theme="light"] .highlight .vc { color: #d91e18 } /* Name.Variable.Class */ +html[data-theme="light"] .highlight .vg { color: #d91e18 } /* Name.Variable.Global */ +html[data-theme="light"] .highlight .vi { color: #d91e18 } /* Name.Variable.Instance */ +html[data-theme="light"] .highlight .vm { color: #797129 } /* Name.Variable.Magic */ +html[data-theme="light"] .highlight .il { color: #797129 } /* Literal.Number.Integer.Long */ +html[data-theme="dark"] .highlight pre { line-height: 125%; } +html[data-theme="dark"] .highlight td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +html[data-theme="dark"] .highlight span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +html[data-theme="dark"] .highlight td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +html[data-theme="dark"] .highlight span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +html[data-theme="dark"] .highlight .hll { background-color: #ffd9002e } +html[data-theme="dark"] .highlight { background: #2b2b2b; color: #f8f8f2 } +html[data-theme="dark"] .highlight .c { color: #ffd900 } /* Comment */ +html[data-theme="dark"] .highlight .err { color: #ffa07a } /* Error */ +html[data-theme="dark"] .highlight .k { color: #dcc6e0 } /* Keyword */ +html[data-theme="dark"] .highlight .l { color: #ffd900 } /* Literal */ +html[data-theme="dark"] .highlight .n { color: #f8f8f2 } /* Name */ +html[data-theme="dark"] .highlight .o { color: #abe338 } /* Operator */ +html[data-theme="dark"] .highlight .p { color: #f8f8f2 } /* Punctuation */ +html[data-theme="dark"] .highlight .ch { color: #ffd900 } /* Comment.Hashbang */ +html[data-theme="dark"] .highlight .cm { color: #ffd900 } /* Comment.Multiline */ +html[data-theme="dark"] .highlight .cp { color: #ffd900 } /* Comment.Preproc */ +html[data-theme="dark"] .highlight .cpf { color: #ffd900 } /* Comment.PreprocFile */ +html[data-theme="dark"] .highlight .c1 { color: #ffd900 } /* Comment.Single */ +html[data-theme="dark"] .highlight .cs { color: #ffd900 } /* Comment.Special */ +html[data-theme="dark"] .highlight .gd { color: #00e0e0 } /* Generic.Deleted */ +html[data-theme="dark"] .highlight .ge { font-style: italic } /* Generic.Emph */ +html[data-theme="dark"] .highlight .gh { color: #00e0e0 } /* Generic.Heading */ +html[data-theme="dark"] .highlight .gs { font-weight: bold } /* Generic.Strong */ +html[data-theme="dark"] .highlight .gu { color: #00e0e0 } /* Generic.Subheading */ +html[data-theme="dark"] .highlight .kc { color: #dcc6e0 } /* Keyword.Constant */ +html[data-theme="dark"] .highlight .kd { color: #dcc6e0 } /* Keyword.Declaration */ +html[data-theme="dark"] .highlight .kn { color: #dcc6e0 } /* Keyword.Namespace */ +html[data-theme="dark"] .highlight .kp { color: #dcc6e0 } /* Keyword.Pseudo */ +html[data-theme="dark"] .highlight .kr { color: #dcc6e0 } /* Keyword.Reserved */ +html[data-theme="dark"] .highlight .kt { color: #ffd900 } /* Keyword.Type */ +html[data-theme="dark"] .highlight .ld { color: #ffd900 } /* Literal.Date */ +html[data-theme="dark"] .highlight .m { color: #ffd900 } /* Literal.Number */ +html[data-theme="dark"] .highlight .s { color: #abe338 } /* Literal.String */ +html[data-theme="dark"] .highlight .na { color: #ffd900 } /* Name.Attribute */ +html[data-theme="dark"] .highlight .nb { color: #ffd900 } /* Name.Builtin */ +html[data-theme="dark"] .highlight .nc { color: #00e0e0 } /* Name.Class */ +html[data-theme="dark"] .highlight .no { color: #00e0e0 } /* Name.Constant */ +html[data-theme="dark"] .highlight .nd { color: #ffd900 } /* Name.Decorator */ +html[data-theme="dark"] .highlight .ni { color: #abe338 } /* Name.Entity */ +html[data-theme="dark"] .highlight .ne { color: #dcc6e0 } /* Name.Exception */ +html[data-theme="dark"] .highlight .nf { color: #00e0e0 } /* Name.Function */ +html[data-theme="dark"] .highlight .nl { color: #ffd900 } /* Name.Label */ +html[data-theme="dark"] .highlight .nn { color: #f8f8f2 } /* Name.Namespace */ +html[data-theme="dark"] .highlight .nx { color: #f8f8f2 } /* Name.Other */ +html[data-theme="dark"] .highlight .py { color: #00e0e0 } /* Name.Property */ +html[data-theme="dark"] .highlight .nt { color: #00e0e0 } /* Name.Tag */ +html[data-theme="dark"] .highlight .nv { color: #ffa07a } /* Name.Variable */ +html[data-theme="dark"] .highlight .ow { color: #dcc6e0 } /* Operator.Word */ +html[data-theme="dark"] .highlight .pm { color: #f8f8f2 } /* Punctuation.Marker */ +html[data-theme="dark"] .highlight .w { color: #f8f8f2 } /* Text.Whitespace */ +html[data-theme="dark"] .highlight .mb { color: #ffd900 } /* Literal.Number.Bin */ +html[data-theme="dark"] .highlight .mf { color: #ffd900 } /* Literal.Number.Float */ +html[data-theme="dark"] .highlight .mh { color: #ffd900 } /* Literal.Number.Hex */ +html[data-theme="dark"] .highlight .mi { color: #ffd900 } /* Literal.Number.Integer */ +html[data-theme="dark"] .highlight .mo { color: #ffd900 } /* Literal.Number.Oct */ +html[data-theme="dark"] .highlight .sa { color: #abe338 } /* Literal.String.Affix */ +html[data-theme="dark"] .highlight .sb { color: #abe338 } /* Literal.String.Backtick */ +html[data-theme="dark"] .highlight .sc { color: #abe338 } /* Literal.String.Char */ +html[data-theme="dark"] .highlight .dl { color: #abe338 } /* Literal.String.Delimiter */ +html[data-theme="dark"] .highlight .sd { color: #abe338 } /* Literal.String.Doc */ +html[data-theme="dark"] .highlight .s2 { color: #abe338 } /* Literal.String.Double */ +html[data-theme="dark"] .highlight .se { color: #abe338 } /* Literal.String.Escape */ +html[data-theme="dark"] .highlight .sh { color: #abe338 } /* Literal.String.Heredoc */ +html[data-theme="dark"] .highlight .si { color: #abe338 } /* Literal.String.Interpol */ +html[data-theme="dark"] .highlight .sx { color: #abe338 } /* Literal.String.Other */ +html[data-theme="dark"] .highlight .sr { color: #ffa07a } /* Literal.String.Regex */ +html[data-theme="dark"] .highlight .s1 { color: #abe338 } /* Literal.String.Single */ +html[data-theme="dark"] .highlight .ss { color: #00e0e0 } /* Literal.String.Symbol */ +html[data-theme="dark"] .highlight .bp { color: #ffd900 } /* Name.Builtin.Pseudo */ +html[data-theme="dark"] .highlight .fm { color: #00e0e0 } /* Name.Function.Magic */ +html[data-theme="dark"] .highlight .vc { color: #ffa07a } /* Name.Variable.Class */ +html[data-theme="dark"] .highlight .vg { color: #ffa07a } /* Name.Variable.Global */ +html[data-theme="dark"] .highlight .vi { color: #ffa07a } /* Name.Variable.Instance */ +html[data-theme="dark"] .highlight .vm { color: #ffd900 } /* Name.Variable.Magic */ +html[data-theme="dark"] .highlight .il { color: #ffd900 } /* Literal.Number.Integer.Long */ \ No newline at end of file diff --git a/_static/sbt-webpack-macros.html b/_static/sbt-webpack-macros.html new file mode 100644 index 000000000..6cbf559fa --- /dev/null +++ b/_static/sbt-webpack-macros.html @@ -0,0 +1,11 @@ + +{% macro head_pre_bootstrap() %} + +{% endmacro %} + +{% macro body_post() %} + +{% endmacro %} diff --git a/_static/scripts/bootstrap.js b/_static/scripts/bootstrap.js new file mode 100644 index 000000000..4e209b0e1 --- /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:()=>E,afterRead:()=>v,afterWrite:()=>C,applyStyles:()=>$,arrow:()=>J,auto:()=>a,basePlacements:()=>l,beforeMain:()=>y,beforeRead:()=>_,beforeWrite:()=>A,bottom:()=>s,clippingParents:()=>d,computeStyles:()=>it,createPopper:()=>Dt,createPopperBase:()=>St,createPopperLite:()=>$t,detectOverflow:()=>_t,end:()=>h,eventListeners:()=>st,flip:()=>bt,hide:()=>wt,left:()=>r,main:()=>w,modifierPhases:()=>O,offset:()=>Et,placements:()=>g,popper:()=>f,popperGenerator:()=>Lt,popperOffsets:()=>At,preventOverflow:()=>Tt,read:()=>b,reference:()=>p,right:()=>o,start:()=>c,top:()=>n,variationPlacements:()=>m,viewport:()=>u,write:()=>T});var i={};t.r(i),t.d(i,{Alert:()=>Oe,Button:()=>ke,Carousel:()=>ri,Collapse:()=>yi,Dropdown:()=>Vi,Modal:()=>xn,Offcanvas:()=>Vn,Popover:()=>fs,ScrollSpy:()=>Ts,Tab:()=>Ks,Toast:()=>lo,Tooltip:()=>hs});var n="top",s="bottom",o="right",r="left",a="auto",l=[n,s,o,r],c="start",h="end",d="clippingParents",u="viewport",f="popper",p="reference",m=l.reduce((function(t,e){return t.concat([e+"-"+c,e+"-"+h])}),[]),g=[].concat(l,[a]).reduce((function(t,e){return t.concat([e,e+"-"+c,e+"-"+h])}),[]),_="beforeRead",b="read",v="afterRead",y="beforeMain",w="main",E="afterMain",A="beforeWrite",T="write",C="afterWrite",O=[_,b,v,y,w,E,A,T,C];function x(t){return t?(t.nodeName||"").toLowerCase():null}function k(t){if(null==t)return window;if("[object Window]"!==t.toString()){var e=t.ownerDocument;return e&&e.defaultView||window}return t}function L(t){return t instanceof k(t).Element||t instanceof Element}function S(t){return t instanceof k(t).HTMLElement||t instanceof HTMLElement}function D(t){return"undefined"!=typeof ShadowRoot&&(t instanceof k(t).ShadowRoot||t instanceof ShadowRoot)}const $={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];S(s)&&x(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}),{});S(n)&&x(n)&&(Object.assign(n.style,o),Object.keys(s).forEach((function(t){n.removeAttribute(t)})))}))}},requires:["computeStyles"]};function I(t){return t.split("-")[0]}var N=Math.max,P=Math.min,M=Math.round;function j(){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 F(){return!/^((?!chrome|android).)*safari/i.test(j())}function H(t,e,i){void 0===e&&(e=!1),void 0===i&&(i=!1);var n=t.getBoundingClientRect(),s=1,o=1;e&&S(t)&&(s=t.offsetWidth>0&&M(n.width)/t.offsetWidth||1,o=t.offsetHeight>0&&M(n.height)/t.offsetHeight||1);var r=(L(t)?k(t):window).visualViewport,a=!F()&&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 B(t){var e=H(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 W(t,e){var i=e.getRootNode&&e.getRootNode();if(t.contains(e))return!0;if(i&&D(i)){var n=e;do{if(n&&t.isSameNode(n))return!0;n=n.parentNode||n.host}while(n)}return!1}function z(t){return k(t).getComputedStyle(t)}function R(t){return["table","td","th"].indexOf(x(t))>=0}function q(t){return((L(t)?t.ownerDocument:t.document)||window.document).documentElement}function V(t){return"html"===x(t)?t:t.assignedSlot||t.parentNode||(D(t)?t.host:null)||q(t)}function Y(t){return S(t)&&"fixed"!==z(t).position?t.offsetParent:null}function K(t){for(var e=k(t),i=Y(t);i&&R(i)&&"static"===z(i).position;)i=Y(i);return i&&("html"===x(i)||"body"===x(i)&&"static"===z(i).position)?e:i||function(t){var e=/firefox/i.test(j());if(/Trident/i.test(j())&&S(t)&&"fixed"===z(t).position)return null;var i=V(t);for(D(i)&&(i=i.host);S(i)&&["html","body"].indexOf(x(i))<0;){var n=z(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 Q(t){return["top","bottom"].indexOf(t)>=0?"x":"y"}function X(t,e,i){return N(t,P(e,i))}function U(t){return Object.assign({},{top:0,right:0,bottom:0,left:0},t)}function G(t,e){return e.reduce((function(e,i){return e[i]=t,e}),{})}const J={name:"arrow",enabled:!0,phase:"main",fn:function(t){var e,i=t.state,a=t.name,c=t.options,h=i.elements.arrow,d=i.modifiersData.popperOffsets,u=I(i.placement),f=Q(u),p=[r,o].indexOf(u)>=0?"height":"width";if(h&&d){var m=function(t,e){return U("number"!=typeof(t="function"==typeof t?t(Object.assign({},e.rects,{placement:e.placement})):t)?t:G(t,l))}(c.padding,i),g=B(h),_="y"===f?n:r,b="y"===f?s:o,v=i.rects.reference[p]+i.rects.reference[f]-d[f]-i.rects.popper[p],y=d[f]-i.rects.reference[f],w=K(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=X(T,O,C),k=f;i.modifiersData[a]=((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)))&&W(e.elements.popper,n)&&(e.elements.arrow=n)},requires:["popperOffsets"],requiresIfExists:["preventOverflow"]};function Z(t){return t.split("-")[1]}var tt={top:"auto",right:"auto",bottom:"auto",left:"auto"};function et(t){var e,i=t.popper,a=t.popperRect,l=t.placement,c=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=r,C=n,O=window;if(p){var x=K(i),L="clientHeight",S="clientWidth";x===k(i)&&"static"!==z(x=q(i)).position&&"absolute"===u&&(L="scrollHeight",S="scrollWidth"),(l===n||(l===r||l===o)&&c===h)&&(C=s,y-=(g&&x===O&&O.visualViewport?O.visualViewport.height:x[L])-a.height,y*=f?1:-1),l!==r&&(l!==n&&l!==s||c!==h)||(T=o,b-=(g&&x===O&&O.visualViewport?O.visualViewport.width:x[S])-a.width,b*=f?1:-1)}var D,$=Object.assign({position:u},p&&tt),I=!0===m?function(t,e){var i=t.x,n=t.y,s=e.devicePixelRatio||1;return{x:M(i*s)/s||0,y:M(n*s)/s||0}}({x:b,y},k(i)):{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 it={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:I(e.placement),variation:Z(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,et(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,et(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 nt={passive:!0};const st={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=k(e.elements.popper),c=[].concat(e.scrollParents.reference,e.scrollParents.popper);return o&&c.forEach((function(t){t.addEventListener("scroll",i.update,nt)})),a&&l.addEventListener("resize",i.update,nt),function(){o&&c.forEach((function(t){t.removeEventListener("scroll",i.update,nt)})),a&&l.removeEventListener("resize",i.update,nt)}},data:{}};var ot={left:"right",right:"left",bottom:"top",top:"bottom"};function rt(t){return t.replace(/left|right|bottom|top/g,(function(t){return ot[t]}))}var at={start:"end",end:"start"};function lt(t){return t.replace(/start|end/g,(function(t){return at[t]}))}function ct(t){var e=k(t);return{scrollLeft:e.pageXOffset,scrollTop:e.pageYOffset}}function ht(t){return H(q(t)).left+ct(t).scrollLeft}function dt(t){var e=z(t),i=e.overflow,n=e.overflowX,s=e.overflowY;return/auto|scroll|overlay|hidden/.test(i+s+n)}function ut(t){return["html","body","#document"].indexOf(x(t))>=0?t.ownerDocument.body:S(t)&&dt(t)?t:ut(V(t))}function ft(t,e){var i;void 0===e&&(e=[]);var n=ut(t),s=n===(null==(i=t.ownerDocument)?void 0:i.body),o=k(n),r=s?[o].concat(o.visualViewport||[],dt(n)?n:[]):n,a=e.concat(r);return s?a:a.concat(ft(V(r)))}function pt(t){return Object.assign({},t,{left:t.x,top:t.y,right:t.x+t.width,bottom:t.y+t.height})}function mt(t,e,i){return e===u?pt(function(t,e){var i=k(t),n=q(t),s=i.visualViewport,o=n.clientWidth,r=n.clientHeight,a=0,l=0;if(s){o=s.width,r=s.height;var c=F();(c||!c&&"fixed"===e)&&(a=s.offsetLeft,l=s.offsetTop)}return{width:o,height:r,x:a+ht(t),y:l}}(t,i)):L(e)?function(t,e){var i=H(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):pt(function(t){var e,i=q(t),n=ct(t),s=null==(e=t.ownerDocument)?void 0:e.body,o=N(i.scrollWidth,i.clientWidth,s?s.scrollWidth:0,s?s.clientWidth:0),r=N(i.scrollHeight,i.clientHeight,s?s.scrollHeight:0,s?s.clientHeight:0),a=-n.scrollLeft+ht(t),l=-n.scrollTop;return"rtl"===z(s||i).direction&&(a+=N(i.clientWidth,s?s.clientWidth:0)-o),{width:o,height:r,x:a,y:l}}(q(t)))}function gt(t){var e,i=t.reference,a=t.element,l=t.placement,d=l?I(l):null,u=l?Z(l):null,f=i.x+i.width/2-a.width/2,p=i.y+i.height/2-a.height/2;switch(d){case n:e={x:f,y:i.y-a.height};break;case s:e={x:f,y:i.y+i.height};break;case o:e={x:i.x+i.width,y:p};break;case r:e={x:i.x-a.width,y:p};break;default:e={x:i.x,y:i.y}}var m=d?Q(d):null;if(null!=m){var g="y"===m?"height":"width";switch(u){case c:e[m]=e[m]-(i[g]/2-a[g]/2);break;case h:e[m]=e[m]+(i[g]/2-a[g]/2)}}return e}function _t(t,e){void 0===e&&(e={});var i=e,r=i.placement,a=void 0===r?t.placement:r,c=i.strategy,h=void 0===c?t.strategy:c,m=i.boundary,g=void 0===m?d:m,_=i.rootBoundary,b=void 0===_?u:_,v=i.elementContext,y=void 0===v?f:v,w=i.altBoundary,E=void 0!==w&&w,A=i.padding,T=void 0===A?0:A,C=U("number"!=typeof T?T:G(T,l)),O=y===f?p:f,k=t.rects.popper,D=t.elements[E?O:y],$=function(t,e,i,n){var s="clippingParents"===e?function(t){var e=ft(V(t)),i=["absolute","fixed"].indexOf(z(t).position)>=0&&S(t)?K(t):t;return L(i)?e.filter((function(t){return L(t)&&W(t,i)&&"body"!==x(t)})):[]}(t):[].concat(e),o=[].concat(s,[i]),r=o[0],a=o.reduce((function(e,i){var s=mt(t,i,n);return e.top=N(s.top,e.top),e.right=P(s.right,e.right),e.bottom=P(s.bottom,e.bottom),e.left=N(s.left,e.left),e}),mt(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}(L(D)?D:D.contextElement||q(t.elements.popper),g,b,h),I=H(t.elements.reference),M=gt({reference:I,element:k,strategy:"absolute",placement:a}),j=pt(Object.assign({},k,M)),F=y===f?j:I,B={top:$.top-F.top+C.top,bottom:F.bottom-$.bottom+C.bottom,left:$.left-F.left+C.left,right:F.right-$.right+C.right},R=t.modifiersData.offset;if(y===f&&R){var Y=R[a];Object.keys(B).forEach((function(t){var e=[o,s].indexOf(t)>=0?1:-1,i=[n,s].indexOf(t)>=0?"y":"x";B[t]+=Y[i]*e}))}return B}const bt={name:"flip",enabled:!0,phase:"main",fn:function(t){var e=t.state,i=t.options,h=t.name;if(!e.modifiersData[h]._skip){for(var d=i.mainAxis,u=void 0===d||d,f=i.altAxis,p=void 0===f||f,_=i.fallbackPlacements,b=i.padding,v=i.boundary,y=i.rootBoundary,w=i.altBoundary,E=i.flipVariations,A=void 0===E||E,T=i.allowedAutoPlacements,C=e.options.placement,O=I(C),x=_||(O!==C&&A?function(t){if(I(t)===a)return[];var e=rt(t);return[lt(t),e,lt(e)]}(C):[rt(C)]),k=[C].concat(x).reduce((function(t,i){return t.concat(I(i)===a?function(t,e){void 0===e&&(e={});var i=e,n=i.placement,s=i.boundary,o=i.rootBoundary,r=i.padding,a=i.flipVariations,c=i.allowedAutoPlacements,h=void 0===c?g:c,d=Z(n),u=d?a?m:m.filter((function(t){return Z(t)===d})):l,f=u.filter((function(t){return h.indexOf(t)>=0}));0===f.length&&(f=u);var p=f.reduce((function(e,i){return e[i]=_t(t,{placement:i,boundary:s,rootBoundary:o,padding:r})[I(i)],e}),{});return Object.keys(p).sort((function(t,e){return p[t]-p[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,$=!0,N=k[0],P=0;P=0,B=H?"width":"height",W=_t(e,{placement:M,boundary:v,rootBoundary:y,altBoundary:w,padding:b}),z=H?F?o:r:F?s:n;L[B]>S[B]&&(z=rt(z));var R=rt(z),q=[];if(u&&q.push(W[j]<=0),p&&q.push(W[z]<=0,W[R]<=0),q.every((function(t){return t}))){N=M,$=!1;break}D.set(M,q)}if($)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 vt(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 yt(t){return[n,o,s,r].some((function(e){return t[e]>=0}))}const wt={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=_t(e,{elementContext:"reference"}),a=_t(e,{altBoundary:!0}),l=vt(r,n),c=vt(a,s,o),h=yt(l),d=yt(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})}},Et={name:"offset",enabled:!0,phase:"main",requires:["popperOffsets"],fn:function(t){var e=t.state,i=t.options,s=t.name,a=i.offset,l=void 0===a?[0,0]:a,c=g.reduce((function(t,i){return t[i]=function(t,e,i){var s=I(t),a=[r,n].indexOf(s)>=0?-1:1,l="function"==typeof i?i(Object.assign({},e,{placement:t})):i,c=l[0],h=l[1];return c=c||0,h=(h||0)*a,[r,o].indexOf(s)>=0?{x:h,y:c}:{x:c,y:h}}(i,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[s]=c}},At={name:"popperOffsets",enabled:!0,phase:"read",fn:function(t){var e=t.state,i=t.name;e.modifiersData[i]=gt({reference:e.rects.reference,element:e.rects.popper,strategy:"absolute",placement:e.placement})},data:{}},Tt={name:"preventOverflow",enabled:!0,phase:"main",fn:function(t){var e=t.state,i=t.options,a=t.name,l=i.mainAxis,h=void 0===l||l,d=i.altAxis,u=void 0!==d&&d,f=i.boundary,p=i.rootBoundary,m=i.altBoundary,g=i.padding,_=i.tether,b=void 0===_||_,v=i.tetherOffset,y=void 0===v?0:v,w=_t(e,{boundary:f,rootBoundary:p,padding:g,altBoundary:m}),E=I(e.placement),A=Z(e.placement),T=!A,C=Q(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),$=e.modifiersData.offset?e.modifiersData.offset[e.placement]:null,M={x:0,y:0};if(x){if(h){var j,F="y"===C?n:r,H="y"===C?s:o,W="y"===C?"height":"width",z=x[C],R=z+w[F],q=z-w[H],V=b?-L[W]/2:0,Y=A===c?k[W]:L[W],U=A===c?-L[W]:-k[W],G=e.elements.arrow,J=b&&G?B(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[H],nt=X(0,k[W],J[W]),st=T?k[W]/2-V-nt-et-D.mainAxis:Y-nt-et-D.mainAxis,ot=T?-k[W]/2+V+nt+it+D.mainAxis:U+nt+it+D.mainAxis,rt=e.elements.arrow&&K(e.elements.arrow),at=rt?"y"===C?rt.clientTop||0:rt.clientLeft||0:0,lt=null!=(j=null==$?void 0:$[C])?j:0,ct=z+ot-lt,ht=X(b?P(R,z+st-lt-at):R,z,b?N(q,ct):q);x[C]=ht,M[C]=ht-z}if(u){var dt,ut="x"===C?n:r,ft="x"===C?s:o,pt=x[O],mt="y"===O?"height":"width",gt=pt+w[ut],bt=pt-w[ft],vt=-1!==[n,r].indexOf(E),yt=null!=(dt=null==$?void 0:$[O])?dt:0,wt=vt?gt: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=X(t,e,i);return n>i?i:n}(wt,pt,Et):X(b?wt:gt,pt,b?Et:bt);x[O]=At,M[O]=At-pt}e.modifiersData[a]=M}},requiresIfExists:["offset"]};function Ct(t,e,i){void 0===i&&(i=!1);var n,s,o=S(e),r=S(e)&&function(t){var e=t.getBoundingClientRect(),i=M(e.width)/t.offsetWidth||1,n=M(e.height)/t.offsetHeight||1;return 1!==i||1!==n}(e),a=q(e),l=H(t,r,i),c={scrollLeft:0,scrollTop:0},h={x:0,y:0};return(o||!o&&!i)&&(("body"!==x(e)||dt(a))&&(c=(n=e)!==k(n)&&S(n)?{scrollLeft:(s=n).scrollLeft,scrollTop:s.scrollTop}:ct(n)),S(e)?((h=H(e,!0)).x+=e.clientLeft,h.y+=e.clientTop):a&&(h.x=ht(a))),{x:l.left+c.scrollLeft-h.x,y:l.top+c.scrollTop-h.y,width:l.width,height:l.height}}function Ot(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 xt={placement:"bottom",modifiers:[],strategy:"absolute"};function kt(){for(var t=arguments.length,e=new Array(t),i=0;iIt.has(t)&&It.get(t).get(e)||null,remove(t,e){if(!It.has(t))return;const i=It.get(t);i.delete(e),0===i.size&&It.delete(t)}},Pt="transitionend",Mt=t=>(t&&window.CSS&&window.CSS.escape&&(t=t.replace(/#([^\s"#']+)/g,((t,e)=>`#${CSS.escape(e)}`))),t),jt=t=>{t.dispatchEvent(new Event(Pt))},Ft=t=>!(!t||"object"!=typeof t)&&(void 0!==t.jquery&&(t=t[0]),void 0!==t.nodeType),Ht=t=>Ft(t)?t.jquery?t[0]:t:"string"==typeof t&&t.length>0?document.querySelector(Mt(t)):null,Bt=t=>{if(!Ft(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},Wt=t=>!t||t.nodeType!==Node.ELEMENT_NODE||!!t.classList.contains("disabled")||(void 0!==t.disabled?t.disabled:t.hasAttribute("disabled")&&"false"!==t.getAttribute("disabled")),zt=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?zt(t.parentNode):null},Rt=()=>{},qt=t=>{t.offsetHeight},Vt=()=>window.jQuery&&!document.body.hasAttribute("data-bs-no-jquery")?window.jQuery:null,Yt=[],Kt=()=>"rtl"===document.documentElement.dir,Qt=t=>{var e;e=()=>{const e=Vt();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?(Yt.length||document.addEventListener("DOMContentLoaded",(()=>{for(const t of Yt)t()})),Yt.push(e)):e()},Xt=(t,e=[],i=t)=>"function"==typeof t?t(...e):i,Ut=(t,e,i=!0)=>{if(!i)return void Xt(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(Pt,o),Xt(t))};e.addEventListener(Pt,o),setTimeout((()=>{s||jt(e)}),n)},Gt=(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))])},Jt=/[^.]*(?=\..*)\.|.*/,Zt=/\..*/,te=/::\d+$/,ee={};let ie=1;const ne={mouseenter:"mouseover",mouseleave:"mouseout"},se=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 oe(t,e){return e&&`${e}::${ie++}`||t.uidEvent||ie++}function re(t){const e=oe(t);return t.uidEvent=e,ee[e]=ee[e]||{},ee[e]}function ae(t,e,i=null){return Object.values(t).find((t=>t.callable===e&&t.delegationSelector===i))}function le(t,e,i){const n="string"==typeof e,s=n?i:e||i;let o=ue(t);return se.has(o)||(o=t),[n,s,o]}function ce(t,e,i,n,s){if("string"!=typeof e||!t)return;let[o,r,a]=le(e,i,n);if(e in ne){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=re(t),c=l[a]||(l[a]={}),h=ae(c,r,o?i:null);if(h)return void(h.oneOff=h.oneOff&&s);const d=oe(r,e.replace(Jt,"")),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 pe(s,{delegateTarget:r}),n.oneOff&&fe.off(t,s.type,e,i),i.apply(r,[s])}}(t,i,r):function(t,e){return function i(n){return pe(n,{delegateTarget:t}),i.oneOff&&fe.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 he(t,e,i,n,s){const o=ae(e[i],n,s);o&&(t.removeEventListener(i,o,Boolean(s)),delete e[i][o.uidEvent])}function de(t,e,i,n){const s=e[i]||{};for(const[o,r]of Object.entries(s))o.includes(n)&&he(t,e,i,r.callable,r.delegationSelector)}function ue(t){return t=t.replace(Zt,""),ne[t]||t}const fe={on(t,e,i,n){ce(t,e,i,n,!1)},one(t,e,i,n){ce(t,e,i,n,!0)},off(t,e,i,n){if("string"!=typeof e||!t)return;const[s,o,r]=le(e,i,n),a=r!==e,l=re(t),c=l[r]||{},h=e.startsWith(".");if(void 0===o){if(h)for(const i of Object.keys(l))de(t,l,i,e.slice(1));for(const[i,n]of Object.entries(c)){const s=i.replace(te,"");a&&!e.includes(s)||he(t,l,r,n.callable,n.delegationSelector)}}else{if(!Object.keys(c).length)return;he(t,l,r,o,s?i:null)}},trigger(t,e,i){if("string"!=typeof e||!t)return null;const n=Vt();let s=null,o=!0,r=!0,a=!1;e!==ue(e)&&n&&(s=n.Event(e,i),n(t).trigger(s),o=!s.isPropagationStopped(),r=!s.isImmediatePropagationStopped(),a=s.isDefaultPrevented());const l=pe(new Event(e,{bubbles:o,cancelable:!0}),i);return a&&l.preventDefault(),r&&t.dispatchEvent(l),l.defaultPrevented&&s&&s.preventDefault(),l}};function pe(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 me(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 ge(t){return t.replace(/[A-Z]/g,(t=>`-${t.toLowerCase()}`))}const _e={setDataAttribute(t,e,i){t.setAttribute(`data-bs-${ge(e)}`,i)},removeDataAttribute(t,e){t.removeAttribute(`data-bs-${ge(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]=me(t.dataset[n])}return e},getDataAttribute:(t,e)=>me(t.getAttribute(`data-bs-${ge(e)}`))};class be{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=Ft(e)?_e.getDataAttribute(e,"config"):{};return{...this.constructor.Default,..."object"==typeof i?i:{},...Ft(e)?_e.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=Ft(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 ve extends be{constructor(t,e){super(),(t=Ht(t))&&(this._element=t,this._config=this._getConfig(e),Nt.set(this._element,this.constructor.DATA_KEY,this))}dispose(){Nt.remove(this._element,this.constructor.DATA_KEY),fe.off(this._element,this.constructor.EVENT_KEY);for(const t of Object.getOwnPropertyNames(this))this[t]=null}_queueCallback(t,e,i=!0){Ut(t,e,i)}_getConfig(t){return t=this._mergeConfigObj(t,this._element),t=this._configAfterMerge(t),this._typeCheckConfig(t),t}static getInstance(t){return Nt.get(Ht(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 ye=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?Mt(i.trim()):null}return e},we={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=>!Wt(t)&&Bt(t)))},getSelectorFromElement(t){const e=ye(t);return e&&we.findOne(e)?e:null},getElementFromSelector(t){const e=ye(t);return e?we.findOne(e):null},getMultipleElementsFromSelector(t){const e=ye(t);return e?we.find(e):[]}},Ee=(t,e="hide")=>{const i=`click.dismiss${t.EVENT_KEY}`,n=t.NAME;fe.on(document,i,`[data-bs-dismiss="${n}"]`,(function(i){if(["A","AREA"].includes(this.tagName)&&i.preventDefault(),Wt(this))return;const s=we.getElementFromSelector(this)||this.closest(`.${n}`);t.getOrCreateInstance(s)[e]()}))},Ae=".bs.alert",Te=`close${Ae}`,Ce=`closed${Ae}`;class Oe extends ve{static get NAME(){return"alert"}close(){if(fe.trigger(this._element,Te).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(),fe.trigger(this._element,Ce),this.dispose()}static jQueryInterface(t){return this.each((function(){const e=Oe.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)}}))}}Ee(Oe,"close"),Qt(Oe);const xe='[data-bs-toggle="button"]';class ke extends ve{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=ke.getOrCreateInstance(this);"toggle"===t&&e[t]()}))}}fe.on(document,"click.bs.button.data-api",xe,(t=>{t.preventDefault();const e=t.target.closest(xe);ke.getOrCreateInstance(e).toggle()})),Qt(ke);const Le=".bs.swipe",Se=`touchstart${Le}`,De=`touchmove${Le}`,$e=`touchend${Le}`,Ie=`pointerdown${Le}`,Ne=`pointerup${Le}`,Pe={endCallback:null,leftCallback:null,rightCallback:null},Me={endCallback:"(function|null)",leftCallback:"(function|null)",rightCallback:"(function|null)"};class je extends be{constructor(t,e){super(),this._element=t,t&&je.isSupported()&&(this._config=this._getConfig(e),this._deltaX=0,this._supportPointerEvents=Boolean(window.PointerEvent),this._initEvents())}static get Default(){return Pe}static get DefaultType(){return Me}static get NAME(){return"swipe"}dispose(){fe.off(this._element,Le)}_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(),Xt(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&&Xt(e>0?this._config.rightCallback:this._config.leftCallback)}_initEvents(){this._supportPointerEvents?(fe.on(this._element,Ie,(t=>this._start(t))),fe.on(this._element,Ne,(t=>this._end(t))),this._element.classList.add("pointer-event")):(fe.on(this._element,Se,(t=>this._start(t))),fe.on(this._element,De,(t=>this._move(t))),fe.on(this._element,$e,(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 Fe=".bs.carousel",He=".data-api",Be="next",We="prev",ze="left",Re="right",qe=`slide${Fe}`,Ve=`slid${Fe}`,Ye=`keydown${Fe}`,Ke=`mouseenter${Fe}`,Qe=`mouseleave${Fe}`,Xe=`dragstart${Fe}`,Ue=`load${Fe}${He}`,Ge=`click${Fe}${He}`,Je="carousel",Ze="active",ti=".active",ei=".carousel-item",ii=ti+ei,ni={ArrowLeft:Re,ArrowRight:ze},si={interval:5e3,keyboard:!0,pause:"hover",ride:!1,touch:!0,wrap:!0},oi={interval:"(number|boolean)",keyboard:"boolean",pause:"(string|boolean)",ride:"(boolean|string)",touch:"boolean",wrap:"boolean"};class ri extends ve{constructor(t,e){super(t,e),this._interval=null,this._activeElement=null,this._isSliding=!1,this.touchTimeout=null,this._swipeHelper=null,this._indicatorsElement=we.findOne(".carousel-indicators",this._element),this._addEventListeners(),this._config.ride===Je&&this.cycle()}static get Default(){return si}static get DefaultType(){return oi}static get NAME(){return"carousel"}next(){this._slide(Be)}nextWhenVisible(){!document.hidden&&Bt(this._element)&&this.next()}prev(){this._slide(We)}pause(){this._isSliding&&jt(this._element),this._clearInterval()}cycle(){this._clearInterval(),this._updateInterval(),this._interval=setInterval((()=>this.nextWhenVisible()),this._config.interval)}_maybeEnableCycle(){this._config.ride&&(this._isSliding?fe.one(this._element,Ve,(()=>this.cycle())):this.cycle())}to(t){const e=this._getItems();if(t>e.length-1||t<0)return;if(this._isSliding)return void fe.one(this._element,Ve,(()=>this.to(t)));const i=this._getItemIndex(this._getActive());if(i===t)return;const n=t>i?Be:We;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&&fe.on(this._element,Ye,(t=>this._keydown(t))),"hover"===this._config.pause&&(fe.on(this._element,Ke,(()=>this.pause())),fe.on(this._element,Qe,(()=>this._maybeEnableCycle()))),this._config.touch&&je.isSupported()&&this._addTouchEventListeners()}_addTouchEventListeners(){for(const t of we.find(".carousel-item img",this._element))fe.on(t,Xe,(t=>t.preventDefault()));const t={leftCallback:()=>this._slide(this._directionToOrder(ze)),rightCallback:()=>this._slide(this._directionToOrder(Re)),endCallback:()=>{"hover"===this._config.pause&&(this.pause(),this.touchTimeout&&clearTimeout(this.touchTimeout),this.touchTimeout=setTimeout((()=>this._maybeEnableCycle()),500+this._config.interval))}};this._swipeHelper=new je(this._element,t)}_keydown(t){if(/input|textarea/i.test(t.target.tagName))return;const e=ni[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=we.findOne(ti,this._indicatorsElement);e.classList.remove(Ze),e.removeAttribute("aria-current");const i=we.findOne(`[data-bs-slide-to="${t}"]`,this._indicatorsElement);i&&(i.classList.add(Ze),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===Be,s=e||Gt(this._getItems(),i,n,this._config.wrap);if(s===i)return;const o=this._getItemIndex(s),r=e=>fe.trigger(this._element,e,{relatedTarget:s,direction:this._orderToDirection(t),from:this._getItemIndex(i),to:o});if(r(qe).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),qt(s),i.classList.add(l),s.classList.add(l),this._queueCallback((()=>{s.classList.remove(l,c),s.classList.add(Ze),i.classList.remove(Ze,c,l),this._isSliding=!1,r(Ve)}),i,this._isAnimated()),a&&this.cycle()}_isAnimated(){return this._element.classList.contains("slide")}_getActive(){return we.findOne(ii,this._element)}_getItems(){return we.find(ei,this._element)}_clearInterval(){this._interval&&(clearInterval(this._interval),this._interval=null)}_directionToOrder(t){return Kt()?t===ze?We:Be:t===ze?Be:We}_orderToDirection(t){return Kt()?t===We?ze:Re:t===We?Re:ze}static jQueryInterface(t){return this.each((function(){const e=ri.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)}))}}fe.on(document,Ge,"[data-bs-slide], [data-bs-slide-to]",(function(t){const e=we.getElementFromSelector(this);if(!e||!e.classList.contains(Je))return;t.preventDefault();const i=ri.getOrCreateInstance(e),n=this.getAttribute("data-bs-slide-to");return n?(i.to(n),void i._maybeEnableCycle()):"next"===_e.getDataAttribute(this,"slide")?(i.next(),void i._maybeEnableCycle()):(i.prev(),void i._maybeEnableCycle())})),fe.on(window,Ue,(()=>{const t=we.find('[data-bs-ride="carousel"]');for(const e of t)ri.getOrCreateInstance(e)})),Qt(ri);const ai=".bs.collapse",li=`show${ai}`,ci=`shown${ai}`,hi=`hide${ai}`,di=`hidden${ai}`,ui=`click${ai}.data-api`,fi="show",pi="collapse",mi="collapsing",gi=`:scope .${pi} .${pi}`,_i='[data-bs-toggle="collapse"]',bi={parent:null,toggle:!0},vi={parent:"(null|element)",toggle:"boolean"};class yi extends ve{constructor(t,e){super(t,e),this._isTransitioning=!1,this._triggerArray=[];const i=we.find(_i);for(const t of i){const e=we.getSelectorFromElement(t),i=we.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 bi}static get DefaultType(){return vi}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=>yi.getOrCreateInstance(t,{toggle:!1})))),t.length&&t[0]._isTransitioning)return;if(fe.trigger(this._element,li).defaultPrevented)return;for(const e of t)e.hide();const e=this._getDimension();this._element.classList.remove(pi),this._element.classList.add(mi),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(mi),this._element.classList.add(pi,fi),this._element.style[e]="",fe.trigger(this._element,ci)}),this._element,!0),this._element.style[e]=`${this._element[i]}px`}hide(){if(this._isTransitioning||!this._isShown())return;if(fe.trigger(this._element,hi).defaultPrevented)return;const t=this._getDimension();this._element.style[t]=`${this._element.getBoundingClientRect()[t]}px`,qt(this._element),this._element.classList.add(mi),this._element.classList.remove(pi,fi);for(const t of this._triggerArray){const e=we.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(mi),this._element.classList.add(pi),fe.trigger(this._element,di)}),this._element,!0)}_isShown(t=this._element){return t.classList.contains(fi)}_configAfterMerge(t){return t.toggle=Boolean(t.toggle),t.parent=Ht(t.parent),t}_getDimension(){return this._element.classList.contains("collapse-horizontal")?"width":"height"}_initializeChildren(){if(!this._config.parent)return;const t=this._getFirstLevelChildren(_i);for(const e of t){const t=we.getElementFromSelector(e);t&&this._addAriaAndCollapsedClass([e],this._isShown(t))}}_getFirstLevelChildren(t){const e=we.find(gi,this._config.parent);return we.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=yi.getOrCreateInstance(this,e);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t]()}}))}}fe.on(document,ui,_i,(function(t){("A"===t.target.tagName||t.delegateTarget&&"A"===t.delegateTarget.tagName)&&t.preventDefault();for(const t of we.getMultipleElementsFromSelector(this))yi.getOrCreateInstance(t,{toggle:!1}).toggle()})),Qt(yi);const wi="dropdown",Ei=".bs.dropdown",Ai=".data-api",Ti="ArrowUp",Ci="ArrowDown",Oi=`hide${Ei}`,xi=`hidden${Ei}`,ki=`show${Ei}`,Li=`shown${Ei}`,Si=`click${Ei}${Ai}`,Di=`keydown${Ei}${Ai}`,$i=`keyup${Ei}${Ai}`,Ii="show",Ni='[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)',Pi=`${Ni}.${Ii}`,Mi=".dropdown-menu",ji=Kt()?"top-end":"top-start",Fi=Kt()?"top-start":"top-end",Hi=Kt()?"bottom-end":"bottom-start",Bi=Kt()?"bottom-start":"bottom-end",Wi=Kt()?"left-start":"right-start",zi=Kt()?"right-start":"left-start",Ri={autoClose:!0,boundary:"clippingParents",display:"dynamic",offset:[0,2],popperConfig:null,reference:"toggle"},qi={autoClose:"(boolean|string)",boundary:"(string|element)",display:"string",offset:"(array|string|function)",popperConfig:"(null|object|function)",reference:"(string|element|object)"};class Vi extends ve{constructor(t,e){super(t,e),this._popper=null,this._parent=this._element.parentNode,this._menu=we.next(this._element,Mi)[0]||we.prev(this._element,Mi)[0]||we.findOne(Mi,this._parent),this._inNavbar=this._detectNavbar()}static get Default(){return Ri}static get DefaultType(){return qi}static get NAME(){return wi}toggle(){return this._isShown()?this.hide():this.show()}show(){if(Wt(this._element)||this._isShown())return;const t={relatedTarget:this._element};if(!fe.trigger(this._element,ki,t).defaultPrevented){if(this._createPopper(),"ontouchstart"in document.documentElement&&!this._parent.closest(".navbar-nav"))for(const t of[].concat(...document.body.children))fe.on(t,"mouseover",Rt);this._element.focus(),this._element.setAttribute("aria-expanded",!0),this._menu.classList.add(Ii),this._element.classList.add(Ii),fe.trigger(this._element,Li,t)}}hide(){if(Wt(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(!fe.trigger(this._element,Oi,t).defaultPrevented){if("ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))fe.off(t,"mouseover",Rt);this._popper&&this._popper.destroy(),this._menu.classList.remove(Ii),this._element.classList.remove(Ii),this._element.setAttribute("aria-expanded","false"),_e.removeDataAttribute(this._menu,"popper"),fe.trigger(this._element,xi,t)}}_getConfig(t){if("object"==typeof(t=super._getConfig(t)).reference&&!Ft(t.reference)&&"function"!=typeof t.reference.getBoundingClientRect)throw new TypeError(`${wi.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:Ft(this._config.reference)?t=Ht(this._config.reference):"object"==typeof this._config.reference&&(t=this._config.reference);const i=this._getPopperConfig();this._popper=Dt(t,this._menu,i)}_isShown(){return this._menu.classList.contains(Ii)}_getPlacement(){const t=this._parent;if(t.classList.contains("dropend"))return Wi;if(t.classList.contains("dropstart"))return zi;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?Fi:ji:e?Bi:Hi}_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)&&(_e.setDataAttribute(this._menu,"popper","static"),t.modifiers=[{name:"applyStyles",enabled:!1}]),{...t,...Xt(this._config.popperConfig,[t])}}_selectMenuItem({key:t,target:e}){const i=we.find(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)",this._menu).filter((t=>Bt(t)));i.length&&Gt(i,e,t===Ci,!i.includes(e)).focus()}static jQueryInterface(t){return this.each((function(){const e=Vi.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=we.find(Pi);for(const i of e){const e=Vi.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=[Ti,Ci].includes(t.key);if(!n&&!i)return;if(e&&!i)return;t.preventDefault();const s=this.matches(Ni)?this:we.prev(this,Ni)[0]||we.next(this,Ni)[0]||we.findOne(Ni,t.delegateTarget.parentNode),o=Vi.getOrCreateInstance(s);if(n)return t.stopPropagation(),o.show(),void o._selectMenuItem(t);o._isShown()&&(t.stopPropagation(),o.hide(),s.focus())}}fe.on(document,Di,Ni,Vi.dataApiKeydownHandler),fe.on(document,Di,Mi,Vi.dataApiKeydownHandler),fe.on(document,Si,Vi.clearMenus),fe.on(document,$i,Vi.clearMenus),fe.on(document,Si,Ni,(function(t){t.preventDefault(),Vi.getOrCreateInstance(this).toggle()})),Qt(Vi);const Yi="backdrop",Ki="show",Qi=`mousedown.bs.${Yi}`,Xi={className:"modal-backdrop",clickCallback:null,isAnimated:!1,isVisible:!0,rootElement:"body"},Ui={className:"string",clickCallback:"(function|null)",isAnimated:"boolean",isVisible:"boolean",rootElement:"(element|string)"};class Gi extends be{constructor(t){super(),this._config=this._getConfig(t),this._isAppended=!1,this._element=null}static get Default(){return Xi}static get DefaultType(){return Ui}static get NAME(){return Yi}show(t){if(!this._config.isVisible)return void Xt(t);this._append();const e=this._getElement();this._config.isAnimated&&qt(e),e.classList.add(Ki),this._emulateAnimation((()=>{Xt(t)}))}hide(t){this._config.isVisible?(this._getElement().classList.remove(Ki),this._emulateAnimation((()=>{this.dispose(),Xt(t)}))):Xt(t)}dispose(){this._isAppended&&(fe.off(this._element,Qi),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=Ht(t.rootElement),t}_append(){if(this._isAppended)return;const t=this._getElement();this._config.rootElement.append(t),fe.on(t,Qi,(()=>{Xt(this._config.clickCallback)})),this._isAppended=!0}_emulateAnimation(t){Ut(t,this._getElement(),this._config.isAnimated)}}const Ji=".bs.focustrap",Zi=`focusin${Ji}`,tn=`keydown.tab${Ji}`,en="backward",nn={autofocus:!0,trapElement:null},sn={autofocus:"boolean",trapElement:"element"};class on extends be{constructor(t){super(),this._config=this._getConfig(t),this._isActive=!1,this._lastTabNavDirection=null}static get Default(){return nn}static get DefaultType(){return sn}static get NAME(){return"focustrap"}activate(){this._isActive||(this._config.autofocus&&this._config.trapElement.focus(),fe.off(document,Ji),fe.on(document,Zi,(t=>this._handleFocusin(t))),fe.on(document,tn,(t=>this._handleKeydown(t))),this._isActive=!0)}deactivate(){this._isActive&&(this._isActive=!1,fe.off(document,Ji))}_handleFocusin(t){const{trapElement:e}=this._config;if(t.target===document||t.target===e||e.contains(t.target))return;const i=we.focusableChildren(e);0===i.length?e.focus():this._lastTabNavDirection===en?i[i.length-1].focus():i[0].focus()}_handleKeydown(t){"Tab"===t.key&&(this._lastTabNavDirection=t.shiftKey?en:"forward")}}const rn=".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",an=".sticky-top",ln="padding-right",cn="margin-right";class hn{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,ln,(e=>e+t)),this._setElementAttributes(rn,ln,(e=>e+t)),this._setElementAttributes(an,cn,(e=>e-t))}reset(){this._resetElementAttributes(this._element,"overflow"),this._resetElementAttributes(this._element,ln),this._resetElementAttributes(rn,ln),this._resetElementAttributes(an,cn)}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&&_e.setDataAttribute(t,e,i)}_resetElementAttributes(t,e){this._applyManipulationCallback(t,(t=>{const i=_e.getDataAttribute(t,e);null!==i?(_e.removeDataAttribute(t,e),t.style.setProperty(e,i)):t.style.removeProperty(e)}))}_applyManipulationCallback(t,e){if(Ft(t))e(t);else for(const i of we.find(t,this._element))e(i)}}const dn=".bs.modal",un=`hide${dn}`,fn=`hidePrevented${dn}`,pn=`hidden${dn}`,mn=`show${dn}`,gn=`shown${dn}`,_n=`resize${dn}`,bn=`click.dismiss${dn}`,vn=`mousedown.dismiss${dn}`,yn=`keydown.dismiss${dn}`,wn=`click${dn}.data-api`,En="modal-open",An="show",Tn="modal-static",Cn={backdrop:!0,focus:!0,keyboard:!0},On={backdrop:"(boolean|string)",focus:"boolean",keyboard:"boolean"};class xn extends ve{constructor(t,e){super(t,e),this._dialog=we.findOne(".modal-dialog",this._element),this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._isShown=!1,this._isTransitioning=!1,this._scrollBar=new hn,this._addEventListeners()}static get Default(){return Cn}static get DefaultType(){return On}static get NAME(){return"modal"}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||this._isTransitioning||fe.trigger(this._element,mn,{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._isTransitioning=!0,this._scrollBar.hide(),document.body.classList.add(En),this._adjustDialog(),this._backdrop.show((()=>this._showElement(t))))}hide(){this._isShown&&!this._isTransitioning&&(fe.trigger(this._element,un).defaultPrevented||(this._isShown=!1,this._isTransitioning=!0,this._focustrap.deactivate(),this._element.classList.remove(An),this._queueCallback((()=>this._hideModal()),this._element,this._isAnimated())))}dispose(){fe.off(window,dn),fe.off(this._dialog,dn),this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}handleUpdate(){this._adjustDialog()}_initializeBackDrop(){return new Gi({isVisible:Boolean(this._config.backdrop),isAnimated:this._isAnimated()})}_initializeFocusTrap(){return new on({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=we.findOne(".modal-body",this._dialog);e&&(e.scrollTop=0),qt(this._element),this._element.classList.add(An),this._queueCallback((()=>{this._config.focus&&this._focustrap.activate(),this._isTransitioning=!1,fe.trigger(this._element,gn,{relatedTarget:t})}),this._dialog,this._isAnimated())}_addEventListeners(){fe.on(this._element,yn,(t=>{"Escape"===t.key&&(this._config.keyboard?this.hide():this._triggerBackdropTransition())})),fe.on(window,_n,(()=>{this._isShown&&!this._isTransitioning&&this._adjustDialog()})),fe.on(this._element,vn,(t=>{fe.one(this._element,bn,(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(En),this._resetAdjustments(),this._scrollBar.reset(),fe.trigger(this._element,pn)}))}_isAnimated(){return this._element.classList.contains("fade")}_triggerBackdropTransition(){if(fe.trigger(this._element,fn).defaultPrevented)return;const t=this._element.scrollHeight>document.documentElement.clientHeight,e=this._element.style.overflowY;"hidden"===e||this._element.classList.contains(Tn)||(t||(this._element.style.overflowY="hidden"),this._element.classList.add(Tn),this._queueCallback((()=>{this._element.classList.remove(Tn),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=Kt()?"paddingLeft":"paddingRight";this._element.style[t]=`${e}px`}if(!i&&t){const t=Kt()?"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=xn.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t](e)}}))}}fe.on(document,wn,'[data-bs-toggle="modal"]',(function(t){const e=we.getElementFromSelector(this);["A","AREA"].includes(this.tagName)&&t.preventDefault(),fe.one(e,mn,(t=>{t.defaultPrevented||fe.one(e,pn,(()=>{Bt(this)&&this.focus()}))}));const i=we.findOne(".modal.show");i&&xn.getInstance(i).hide(),xn.getOrCreateInstance(e).toggle(this)})),Ee(xn),Qt(xn);const kn=".bs.offcanvas",Ln=".data-api",Sn=`load${kn}${Ln}`,Dn="show",$n="showing",In="hiding",Nn=".offcanvas.show",Pn=`show${kn}`,Mn=`shown${kn}`,jn=`hide${kn}`,Fn=`hidePrevented${kn}`,Hn=`hidden${kn}`,Bn=`resize${kn}`,Wn=`click${kn}${Ln}`,zn=`keydown.dismiss${kn}`,Rn={backdrop:!0,keyboard:!0,scroll:!1},qn={backdrop:"(boolean|string)",keyboard:"boolean",scroll:"boolean"};class Vn extends ve{constructor(t,e){super(t,e),this._isShown=!1,this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._addEventListeners()}static get Default(){return Rn}static get DefaultType(){return qn}static get NAME(){return"offcanvas"}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||fe.trigger(this._element,Pn,{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._backdrop.show(),this._config.scroll||(new hn).hide(),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.classList.add($n),this._queueCallback((()=>{this._config.scroll&&!this._config.backdrop||this._focustrap.activate(),this._element.classList.add(Dn),this._element.classList.remove($n),fe.trigger(this._element,Mn,{relatedTarget:t})}),this._element,!0))}hide(){this._isShown&&(fe.trigger(this._element,jn).defaultPrevented||(this._focustrap.deactivate(),this._element.blur(),this._isShown=!1,this._element.classList.add(In),this._backdrop.hide(),this._queueCallback((()=>{this._element.classList.remove(Dn,In),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._config.scroll||(new hn).reset(),fe.trigger(this._element,Hn)}),this._element,!0)))}dispose(){this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}_initializeBackDrop(){const t=Boolean(this._config.backdrop);return new Gi({className:"offcanvas-backdrop",isVisible:t,isAnimated:!0,rootElement:this._element.parentNode,clickCallback:t?()=>{"static"!==this._config.backdrop?this.hide():fe.trigger(this._element,Fn)}:null})}_initializeFocusTrap(){return new on({trapElement:this._element})}_addEventListeners(){fe.on(this._element,zn,(t=>{"Escape"===t.key&&(this._config.keyboard?this.hide():fe.trigger(this._element,Fn))}))}static jQueryInterface(t){return this.each((function(){const e=Vn.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)}}))}}fe.on(document,Wn,'[data-bs-toggle="offcanvas"]',(function(t){const e=we.getElementFromSelector(this);if(["A","AREA"].includes(this.tagName)&&t.preventDefault(),Wt(this))return;fe.one(e,Hn,(()=>{Bt(this)&&this.focus()}));const i=we.findOne(Nn);i&&i!==e&&Vn.getInstance(i).hide(),Vn.getOrCreateInstance(e).toggle(this)})),fe.on(window,Sn,(()=>{for(const t of we.find(Nn))Vn.getOrCreateInstance(t).show()})),fe.on(window,Bn,(()=>{for(const t of we.find("[aria-modal][class*=show][class*=offcanvas-]"))"fixed"!==getComputedStyle(t).position&&Vn.getOrCreateInstance(t).hide()})),Ee(Vn),Qt(Vn);const Yn={"*":["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:[]},Kn=new Set(["background","cite","href","itemtype","longdesc","poster","src","xlink:href"]),Qn=/^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i,Xn=(t,e)=>{const i=t.nodeName.toLowerCase();return e.includes(i)?!Kn.has(i)||Boolean(Qn.test(t.nodeValue)):e.filter((t=>t instanceof RegExp)).some((t=>t.test(i)))},Un={allowList:Yn,content:{},extraClass:"",html:!1,sanitize:!0,sanitizeFn:null,template:"
"},Gn={allowList:"object",content:"object",extraClass:"(string|function)",html:"boolean",sanitize:"boolean",sanitizeFn:"(null|function)",template:"string"},Jn={entry:"(string|element|function|null)",selector:"(string|element)"};class Zn extends be{constructor(t){super(),this._config=this._getConfig(t)}static get Default(){return Un}static get DefaultType(){return Gn}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},Jn)}_setContent(t,e,i){const n=we.findOne(i,t);n&&((e=this._resolvePossibleFunction(e))?Ft(e)?this._putElementInTemplate(Ht(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)Xn(e,s)||t.removeAttribute(e.nodeName)}return n.body.innerHTML}(t,this._config.allowList,this._config.sanitizeFn):t}_resolvePossibleFunction(t){return Xt(t,[this])}_putElementInTemplate(t,e){if(this._config.html)return e.innerHTML="",void e.append(t);e.textContent=t.textContent}}const ts=new Set(["sanitize","allowList","sanitizeFn"]),es="fade",is="show",ns=".modal",ss="hide.bs.modal",os="hover",rs="focus",as={AUTO:"auto",TOP:"top",RIGHT:Kt()?"left":"right",BOTTOM:"bottom",LEFT:Kt()?"right":"left"},ls={allowList:Yn,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"},cs={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 hs extends ve{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 ls}static get DefaultType(){return cs}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),fe.off(this._element.closest(ns),ss,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=fe.trigger(this._element,this.constructor.eventName("show")),e=(zt(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),fe.trigger(this._element,this.constructor.eventName("inserted"))),this._popper=this._createPopper(i),i.classList.add(is),"ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))fe.on(t,"mouseover",Rt);this._queueCallback((()=>{fe.trigger(this._element,this.constructor.eventName("shown")),!1===this._isHovered&&this._leave(),this._isHovered=!1}),this.tip,this._isAnimated())}hide(){if(this._isShown()&&!fe.trigger(this._element,this.constructor.eventName("hide")).defaultPrevented){if(this._getTipElement().classList.remove(is),"ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))fe.off(t,"mouseover",Rt);this._activeTrigger.click=!1,this._activeTrigger[rs]=!1,this._activeTrigger[os]=!1,this._isHovered=null,this._queueCallback((()=>{this._isWithActiveTrigger()||(this._isHovered||this._disposePopper(),this._element.removeAttribute("aria-describedby"),fe.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(es,is),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(es),e}setContent(t){this._newContent=t,this._isShown()&&(this._disposePopper(),this.show())}_getTemplateFactory(t){return this._templateFactory?this._templateFactory.changeContent(t):this._templateFactory=new Zn({...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(es)}_isShown(){return this.tip&&this.tip.classList.contains(is)}_createPopper(t){const e=Xt(this._config.placement,[this,t,this._element]),i=as[e.toUpperCase()];return Dt(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 Xt(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,...Xt(this._config.popperConfig,[e])}}_setListeners(){const t=this._config.trigger.split(" ");for(const e of t)if("click"===e)fe.on(this._element,this.constructor.eventName("click"),this._config.selector,(t=>{this._initializeOnDelegatedTarget(t).toggle()}));else if("manual"!==e){const t=e===os?this.constructor.eventName("mouseenter"):this.constructor.eventName("focusin"),i=e===os?this.constructor.eventName("mouseleave"):this.constructor.eventName("focusout");fe.on(this._element,t,this._config.selector,(t=>{const e=this._initializeOnDelegatedTarget(t);e._activeTrigger["focusin"===t.type?rs:os]=!0,e._enter()})),fe.on(this._element,i,this._config.selector,(t=>{const e=this._initializeOnDelegatedTarget(t);e._activeTrigger["focusout"===t.type?rs:os]=e._element.contains(t.relatedTarget),e._leave()}))}this._hideModalHandler=()=>{this._element&&this.hide()},fe.on(this._element.closest(ns),ss,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=_e.getDataAttributes(this._element);for(const t of Object.keys(e))ts.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:Ht(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=hs.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}Qt(hs);const ds={...hs.Default,content:"",offset:[0,8],placement:"right",template:'',trigger:"click"},us={...hs.DefaultType,content:"(null|string|element|function)"};class fs extends hs{static get Default(){return ds}static get DefaultType(){return us}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=fs.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}Qt(fs);const ps=".bs.scrollspy",ms=`activate${ps}`,gs=`click${ps}`,_s=`load${ps}.data-api`,bs="active",vs="[href]",ys=".nav-link",ws=`${ys}, .nav-item > ${ys}, .list-group-item`,Es={offset:null,rootMargin:"0px 0px -25%",smoothScroll:!1,target:null,threshold:[.1,.5,1]},As={offset:"(number|null)",rootMargin:"string",smoothScroll:"boolean",target:"element",threshold:"array"};class Ts extends ve{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 Es}static get DefaultType(){return As}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=Ht(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&&(fe.off(this._config.target,gs),fe.on(this._config.target,gs,vs,(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=we.find(vs,this._config.target);for(const e of t){if(!e.hash||Wt(e))continue;const t=we.findOne(decodeURI(e.hash),this._element);Bt(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(bs),this._activateParents(t),fe.trigger(this._element,ms,{relatedTarget:t}))}_activateParents(t){if(t.classList.contains("dropdown-item"))we.findOne(".dropdown-toggle",t.closest(".dropdown")).classList.add(bs);else for(const e of we.parents(t,".nav, .list-group"))for(const t of we.prev(e,ws))t.classList.add(bs)}_clearActiveClass(t){t.classList.remove(bs);const e=we.find(`${vs}.${bs}`,t);for(const t of e)t.classList.remove(bs)}static jQueryInterface(t){return this.each((function(){const e=Ts.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]()}}))}}fe.on(window,_s,(()=>{for(const t of we.find('[data-bs-spy="scroll"]'))Ts.getOrCreateInstance(t)})),Qt(Ts);const Cs=".bs.tab",Os=`hide${Cs}`,xs=`hidden${Cs}`,ks=`show${Cs}`,Ls=`shown${Cs}`,Ss=`click${Cs}`,Ds=`keydown${Cs}`,$s=`load${Cs}`,Is="ArrowLeft",Ns="ArrowRight",Ps="ArrowUp",Ms="ArrowDown",js="Home",Fs="End",Hs="active",Bs="fade",Ws="show",zs=".dropdown-toggle",Rs=`:not(${zs})`,qs='[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]',Vs=`.nav-link${Rs}, .list-group-item${Rs}, [role="tab"]${Rs}, ${qs}`,Ys=`.${Hs}[data-bs-toggle="tab"], .${Hs}[data-bs-toggle="pill"], .${Hs}[data-bs-toggle="list"]`;class Ks extends ve{constructor(t){super(t),this._parent=this._element.closest('.list-group, .nav, [role="tablist"]'),this._parent&&(this._setInitialAttributes(this._parent,this._getChildren()),fe.on(this._element,Ds,(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?fe.trigger(e,Os,{relatedTarget:t}):null;fe.trigger(t,ks,{relatedTarget:e}).defaultPrevented||i&&i.defaultPrevented||(this._deactivate(e,t),this._activate(t,e))}_activate(t,e){t&&(t.classList.add(Hs),this._activate(we.getElementFromSelector(t)),this._queueCallback((()=>{"tab"===t.getAttribute("role")?(t.removeAttribute("tabindex"),t.setAttribute("aria-selected",!0),this._toggleDropDown(t,!0),fe.trigger(t,Ls,{relatedTarget:e})):t.classList.add(Ws)}),t,t.classList.contains(Bs)))}_deactivate(t,e){t&&(t.classList.remove(Hs),t.blur(),this._deactivate(we.getElementFromSelector(t)),this._queueCallback((()=>{"tab"===t.getAttribute("role")?(t.setAttribute("aria-selected",!1),t.setAttribute("tabindex","-1"),this._toggleDropDown(t,!1),fe.trigger(t,xs,{relatedTarget:e})):t.classList.remove(Ws)}),t,t.classList.contains(Bs)))}_keydown(t){if(![Is,Ns,Ps,Ms,js,Fs].includes(t.key))return;t.stopPropagation(),t.preventDefault();const e=this._getChildren().filter((t=>!Wt(t)));let i;if([js,Fs].includes(t.key))i=e[t.key===js?0:e.length-1];else{const n=[Ns,Ms].includes(t.key);i=Gt(e,t.target,n,!0)}i&&(i.focus({preventScroll:!0}),Ks.getOrCreateInstance(i).show())}_getChildren(){return we.find(Vs,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=we.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=we.findOne(t,i);s&&s.classList.toggle(n,e)};n(zs,Hs),n(".dropdown-menu",Ws),i.setAttribute("aria-expanded",e)}_setAttributeIfNotExists(t,e,i){t.hasAttribute(e)||t.setAttribute(e,i)}_elemIsActive(t){return t.classList.contains(Hs)}_getInnerElement(t){return t.matches(Vs)?t:we.findOne(Vs,t)}_getOuterElement(t){return t.closest(".nav-item, .list-group-item")||t}static jQueryInterface(t){return this.each((function(){const e=Ks.getOrCreateInstance(this);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t]()}}))}}fe.on(document,Ss,qs,(function(t){["A","AREA"].includes(this.tagName)&&t.preventDefault(),Wt(this)||Ks.getOrCreateInstance(this).show()})),fe.on(window,$s,(()=>{for(const t of we.find(Ys))Ks.getOrCreateInstance(t)})),Qt(Ks);const Qs=".bs.toast",Xs=`mouseover${Qs}`,Us=`mouseout${Qs}`,Gs=`focusin${Qs}`,Js=`focusout${Qs}`,Zs=`hide${Qs}`,to=`hidden${Qs}`,eo=`show${Qs}`,io=`shown${Qs}`,no="hide",so="show",oo="showing",ro={animation:"boolean",autohide:"boolean",delay:"number"},ao={animation:!0,autohide:!0,delay:5e3};class lo extends ve{constructor(t,e){super(t,e),this._timeout=null,this._hasMouseInteraction=!1,this._hasKeyboardInteraction=!1,this._setListeners()}static get Default(){return ao}static get DefaultType(){return ro}static get NAME(){return"toast"}show(){fe.trigger(this._element,eo).defaultPrevented||(this._clearTimeout(),this._config.animation&&this._element.classList.add("fade"),this._element.classList.remove(no),qt(this._element),this._element.classList.add(so,oo),this._queueCallback((()=>{this._element.classList.remove(oo),fe.trigger(this._element,io),this._maybeScheduleHide()}),this._element,this._config.animation))}hide(){this.isShown()&&(fe.trigger(this._element,Zs).defaultPrevented||(this._element.classList.add(oo),this._queueCallback((()=>{this._element.classList.add(no),this._element.classList.remove(oo,so),fe.trigger(this._element,to)}),this._element,this._config.animation)))}dispose(){this._clearTimeout(),this.isShown()&&this._element.classList.remove(so),super.dispose()}isShown(){return this._element.classList.contains(so)}_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(){fe.on(this._element,Xs,(t=>this._onInteraction(t,!0))),fe.on(this._element,Us,(t=>this._onInteraction(t,!1))),fe.on(this._element,Gs,(t=>this._onInteraction(t,!0))),fe.on(this._element,Js,(t=>this._onInteraction(t,!1)))}_clearTimeout(){clearTimeout(this._timeout),this._timeout=null}static jQueryInterface(t){return this.each((function(){const e=lo.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}function co(t){"loading"!=document.readyState?t():document.addEventListener("DOMContentLoaded",t)}Ee(lo),Qt(lo),co((function(){[].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]')).map((function(t){return new hs(t,{delay:{show:500,hide:100}})}))})),co((function(){document.getElementById("pst-back-to-top").addEventListener("click",(function(){document.body.scrollTop=0,document.documentElement.scrollTop=0}))})),co((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}))})),window.bootstrap=i})(); +//# 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..64e212b1e --- /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,01BCLvD,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,GAAa,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,IAEXsB,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,IEpyInBQ,IAzCA,WAC2B,GAAG93B,MAAM5U,KAChC6H,SAAS+a,iBAAiB,+BAETtd,KAAI,SAAUqnC,GAC/B,OAAO,IAAI,GAAkBA,EAAkB,CAC7ClK,MAAO,CAAEvQ,KAAM,IAAKD,KAAM,MAE9B,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,IAUA5qC,OAAO6qC,UAAY","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
    and