FAST-PEDAGO 1.1.0__tar.gz

fast_pedago-1.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: FAST-PEDAGO
+Version: 1.1.0
+Summary: Lightweight interface to perform simplified OAD analysis using FAST-OAD
+License-Expression: GPL-3.0-only
+Keywords: aircraft,design,multi-disciplinary,teaching,educational
+Author: Ousmane SY
+Author-email: Ousmane.SY@isae-supaero.fr
+Maintainer: Florent LUTZ
+Maintainer-email: Florent.LUTZ2@isae-supaero.fr
+Requires-Python: >=3.10,<3.15
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Dist: appmode (>=0.9.0)
+Requires-Dist: click (>=8.0.3)
+Requires-Dist: fast-oad-core (>=1.10.0)
+Requires-Dist: fast-oad-cs25 (>=0.9.1)
+Requires-Dist: ipyvuetify (>=3.0.0)
+Requires-Dist: ipywidgets (>=7.7.2)
+Requires-Dist: lxml_html_clean
+Requires-Dist: voila (>=0.3.7)
+Project-URL: Homepage, https://github.com/supaero-aircraft-design/FAST-PEDAGO
+Description-Content-Type: text/markdown
+
+# FAST-OAD TRAINING AND INCREMENTAL DEVELOPMENT BRANCH
+
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/supaero-aircraft-design/FAST-PEDAGO/HEAD?labpath=fast_pedago%2Fnotebook%2FFAST_OAD_app.ipynb)
+
+This package offers a lightweight interface to perform simplified OAD analysis using FAST-OAD (https://github.com/fast-aircraft-design/FAST-OAD).
+
+Want to try quickly ?
+-------
+
+You can open the app on a [Binder-hosted Jupyter notebook](https://mybinder.org/v2/gh/supaero-aircraft-design/FAST-PEDAGO/HEAD?labpath=fast_pedago%2Fnotebook%2FFAST_OAD_app.ipynb)
+
+Install
+-------
+
+**Prerequisite**: FAST-PEDAGO needs at least **Python 3.7.0**.
+
+It is recommended (but not required) to install FAST-PEDAGO in a virtual
+environment ([conda](https://docs.conda.io/en/latest/),
+[venv](https://docs.python.org/3.7/library/venv.html), ...).
+
+Once Python is installed, FAST-PEDAGO can be installed using pip, by doing the following:
+
+``` {.bash}
+$ pip install fast-pedago
+```
+
+Once installed the cde can be run by doing the following: 
+``` {.bash}
+$ fast-pedago run
+```

fast_pedago-1.1.0/README.md

@@ -0,0 +1,30 @@
+# FAST-OAD TRAINING AND INCREMENTAL DEVELOPMENT BRANCH
+
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/supaero-aircraft-design/FAST-PEDAGO/HEAD?labpath=fast_pedago%2Fnotebook%2FFAST_OAD_app.ipynb)
+
+This package offers a lightweight interface to perform simplified OAD analysis using FAST-OAD (https://github.com/fast-aircraft-design/FAST-OAD).
+
+Want to try quickly ?
+-------
+
+You can open the app on a [Binder-hosted Jupyter notebook](https://mybinder.org/v2/gh/supaero-aircraft-design/FAST-PEDAGO/HEAD?labpath=fast_pedago%2Fnotebook%2FFAST_OAD_app.ipynb)
+
+Install
+-------
+
+**Prerequisite**: FAST-PEDAGO needs at least **Python 3.7.0**.
+
+It is recommended (but not required) to install FAST-PEDAGO in a virtual
+environment ([conda](https://docs.conda.io/en/latest/),
+[venv](https://docs.python.org/3.7/library/venv.html), ...).
+
+Once Python is installed, FAST-PEDAGO can be installed using pip, by doing the following:
+
+``` {.bash}
+$ pip install fast-pedago
+```
+
+Once installed the cde can be run by doing the following: 
+``` {.bash}
+$ fast-pedago run
+```

fast_pedago-1.1.0/fast_pedago/app.py

@@ -0,0 +1,122 @@
+import logging
+import os
+import shutil
+import sys
+from argparse import (
+    ArgumentDefaultsHelpFormatter,
+    ArgumentParser,
+    RawDescriptionHelpFormatter,
+)
+from pathlib import Path
+
+MAIN_NOTEBOOK_NAME = "FAST_OAD_app.ipynb"
+MAIN_NOTEBOOK_PATH = Path(__file__).parent / "notebook" / MAIN_NOTEBOOK_NAME
+
+
+class Main:
+    """
+    Class for managing command line and doing associated actions
+    """
+
+    def __init__(self):
+        class _CustomFormatter(RawDescriptionHelpFormatter, ArgumentDefaultsHelpFormatter):
+            pass
+
+        self.parser = ArgumentParser(
+            description="FAST pedagogical branch main program",
+            formatter_class=_CustomFormatter,
+        )
+
+    @staticmethod
+    def _run(args):
+        """Run FAST pedagogical branch locally or with server configuration."""
+        machine = "server" if args.server else "local"
+        print(MAIN_NOTEBOOK_PATH)
+        if machine == "server":
+            command = (
+                "voila "
+                "--port=8080 "
+                "--no-browser "
+                "--MappingKernelManager.cull_idle_timeout=7200 "
+                r"""--VoilaConfiguration.file_whitelist="['.*\."""
+                """(png|jpg|gif|xlsx|ico|pdf|json)']" """
+            )
+        else:
+            command = (
+                "voila "
+                r"""--VoilaConfiguration.file_whitelist="['.*\."""
+                """s(png|jpg|gif|xlsx|ico|pdf|json)']" """
+            )
+
+        # To not get an ugly error message when you ctrl+c
+        try:
+            os.system(command + str(MAIN_NOTEBOOK_PATH))  # noqa: S605 this is a literal string, it can be considered safe.
+        except KeyboardInterrupt:
+            sys.exit()
+
+    @staticmethod
+    def _copy_notebook(args):
+        # Should be a pathlib Path already
+        requested_destination = args.destination
+        if requested_destination.exists() and not requested_destination.is_dir():
+            print("Input path should be the path to a directory. Exiting")
+            raise SystemExit(1)
+
+        requested_destination.mkdir(parents=True, exist_ok=True)
+
+        shutil.copy(MAIN_NOTEBOOK_PATH, args.destination)
+        print("You may now run Jupyter with:")
+        print(f'   jupyter lab "{MAIN_NOTEBOOK_NAME}"')
+        return 0
+
+    # ENTRY POINT ============================================================
+    def run(self):
+        """Main function."""
+        subparsers = self.parser.add_subparsers(title="sub-commands")
+
+        # sub-command for running FAST-PEDAGO -----------------------------------
+        parser_run = subparsers.add_parser(
+            "run",
+            help="run FAST-OAD pedagogical branch",
+            description="run FAST-OAD pedagogical branch",
+        )
+
+        parser_run.add_argument(
+            "--server",
+            action="store_true",
+            help="to be used if ran on server",
+        )
+        parser_run.set_defaults(func=self._run)
+
+        # subcommand for copying the notebook ----------------------------------
+        parser_copy = subparsers.add_parser(
+            "copy_notebook",
+            help="copy notebook to target directory to run without voila",
+            description="copy notebook to target directory to run without voila",
+        )
+
+        parser_copy.add_argument(
+            "-d",
+            "--destination",
+            type=Path,
+            required=True,
+            help="Location in which to copy the notebook.",
+        )
+        parser_copy.set_defaults(func=self._copy_notebook)
+
+        # Parse --------------------------------------------------------------
+        args = self.parser.parse_args()
+        try:
+            args.func(args)
+        except AttributeError:
+            self.parser.print_help()
+
+
+def main():
+    log_format = "%(levelname)-8s: %(message)s"
+    logging.basicConfig(level=logging.INFO, format=log_format)
+    Main().run()
+
+
+if __name__ == "__main__":
+    main()

fast_pedago-1.1.0/fast_pedago/configuration/oad_optim_sensitivity_analysis.yml

@@ -0,0 +1,63 @@
+title: Sample OAD Process
+
+input_file: ../workdir/inputs/reference_aircraft_input_file.xml
+output_file: ../workdir/outputs/reference_aircraft_output_file.xml
+
+driver: om.ScipyOptimizeDriver(tol=1e-2, optimizer='COBYLA')
+
+model:
+
+  #  Solvers are defined assuming the OpenMDAO convention "import openmdao.api as om"
+  nonlinear_solver: om.NonlinearBlockGS(maxiter=100, rtol=1e-2)
+  linear_solver: om.DirectSolver()
+
+
+  # Components can be put in sub-groups
+  subgroup:
+
+    # A group can be set with its own solvers.
+    # Uncomment the 2 next lines for using the performance module with "mission_file_path: ::sizing_mission"
+    # nonlinear_solver: om.NonlinearBlockGS(maxiter=100, atol=1e-2, iprint=0)
+    # linear_solver: om.DirectSolver()
+
+    geometry:
+      # An OpenMDAO component is identified by its "id"
+      id: fastoad.geometry.legacy
+    weight:
+      id: fastoad.weight.legacy
+      payload_from_npax: false
+    loads:
+      id: fastoad.loads.legacy
+    mtow:
+      id: fastoad.mass_performances.compute_MTOW
+    hq_tail_sizing:
+      id: fastoad.handling_qualities.tail_sizing
+    hq_static_margin:
+      id: fastoad.handling_qualities.static_margin
+    wing_position:
+      id: fastoad.loop.wing_position
+    aerodynamics_highspeed:
+      id: fastoad.aerodynamics.highspeed.legacy
+    aerodynamics_lowspeed:
+      id: fastoad.aerodynamics.lowspeed.legacy
+    aerodynamics_takeoff:
+      id: fastoad.aerodynamics.takeoff.legacy
+    aerodynamics_landing:
+      id: fastoad.aerodynamics.landing.legacy
+      use_xfoil: false
+  performance:
+    id: fastoad.performances.mission
+    propulsion_id: fastoad.wrapper.propulsion.rubber_engine
+    mission_file_path: ::sizing_breguet
+    out_file: ../workdir/outputs/flight_points.csv
+    adjust_fuel: true
+    is_sizing: true
+  wing_area:
+    id: fastoad.loop.wing_area
+
+model_options:
+  "*":
+    use_inner_solvers: false
+
+submodels:
+  service.aerodynamics.oswald_coefficient: null

fast_pedago-1.1.0/fast_pedago/configuration/oad_sizing_sensitivity_analysis.yml

@@ -0,0 +1,61 @@
+title: Sample OAD Process
+
+input_file: ../workdir/inputs/reference_aircraft_input_file.xml
+output_file: ../workdir/outputs/reference_aircraft_output_file.xml
+
+model:
+
+  #  Solvers are defined assuming the OpenMDAO convention "import openmdao.api as om"
+  nonlinear_solver: om.NonlinearBlockGS(maxiter=100, rtol=1e-5)
+  linear_solver: om.DirectSolver()
+
+
+  # Components can be put in sub-groups
+  subgroup:
+
+    # A group can be set with its own solvers.
+    # Uncomment the 2 next lines for using the performance module with "mission_file_path: ::sizing_mission"
+    # nonlinear_solver: om.NonlinearBlockGS(maxiter=100, atol=1e-2, iprint=0)
+    # linear_solver: om.DirectSolver()
+
+    geometry:
+      # An OpenMDAO component is identified by its "id"
+      id: fastoad.geometry.legacy
+    weight:
+      id: fastoad.weight.legacy
+      payload_from_npax: false
+    loads:
+      id: fastoad.loads.legacy
+    mtow:
+      id: fastoad.mass_performances.compute_MTOW
+    hq_tail_sizing:
+      id: fastoad.handling_qualities.tail_sizing
+    hq_static_margin:
+      id: fastoad.handling_qualities.static_margin
+    wing_position:
+      id: fastoad.loop.wing_position
+    aerodynamics_highspeed:
+      id: fastoad.aerodynamics.highspeed.legacy
+    aerodynamics_lowspeed:
+      id: fastoad.aerodynamics.lowspeed.legacy
+    aerodynamics_takeoff:
+      id: fastoad.aerodynamics.takeoff.legacy
+    aerodynamics_landing:
+      id: fastoad.aerodynamics.landing.legacy
+      use_xfoil: false
+  performance:
+    id: fastoad.performances.mission
+    propulsion_id: fastoad.wrapper.propulsion.rubber_engine
+    mission_file_path: ::sizing_breguet
+    out_file: ../workdir/outputs/flight_points.csv
+    adjust_fuel: true
+    is_sizing: true
+  wing_area:
+    id: fastoad.loop.wing_area
+
+model_options:
+  "*":
+    use_inner_solvers: false
+
+submodels:
+  service.aerodynamics.oswald_coefficient: null

fast_pedago-1.1.0/fast_pedago/gui/__init__.py

@@ -0,0 +1,3 @@
+from .app_interface import AppInterface
+
+__all__ = ["AppInterface"]

fast_pedago-1.1.0/fast_pedago/gui/app_interface.py

@@ -0,0 +1,345 @@
+import logging
+
+import ipyvuetify as v
+
+from fast_pedago.processes import (
+    ProcessLauncher,
+)
+from fast_pedago.utils import PathManager
+
+from .components import (
+    Drawer,
+    Footer,
+    Header,
+    InputsContainer,
+    OutputFiguresContainer,
+    ProcessFiguresContainer,
+    TutorialContainer,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+# As there are margins and padding in the voila template,
+# I have to adjust the padding considering both the spacings
+# in the voila template and the other components sizes.
+TOP_PADDING = "76px"
+LEFT_PADDING = "426px"
+
+
+class AppInterface(v.App):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        PathManager.build_paths()
+
+        # The process toggle starts on MDA and only reports later changes
+        self.is_MDO = False
+
+        # Sets MDA/MDO launcher to run MDA/MDO.
+        self.process_launcher = ProcessLauncher()
+
+        self._build_layout()
+        self._to_tutorial()
+
+    def _to_tutorial(self):
+        """
+        Displays tutorial.
+        """
+        self.footer.start_button.show()
+        self.drawer.hide()
+        self.header.open_drawer_button.hide()
+        self.padding_column.hide()
+        self.main_content.children = [self.tutorial]
+        self.output_figures.hide_graphs()
+
+    def _to_main(self):
+        """
+        Displays main window, with input drawer and tabs to change
+        between residuals/objectives graph and output figures.
+        """
+        self.footer.start_button.hide()
+        self.drawer.show()
+        self.header.open_drawer_button.show()
+        self.padding_column.show()
+        self.drawer.content.children = [self.inputs]
+        self.main_content.children = [self.graphs]
+
+    def _switch_tab(self, change):
+        """
+        Hides the drawer when on outputs tabs, and show it when on
+        inputs tab.
+
+        To be called with "observe" method of a widget.
+        """
+        data = change["new"]
+
+        if data == "outputs":
+            self.drawer.hide()
+            self.header.open_drawer_button.hide()
+            self.padding_column.hide()
+        else:
+            self.drawer.show()
+            self.header.open_drawer_button.show()
+            self.padding_column.show()
+
+        self.graphs_window.v_model = data
+
+    def _build_layout(self):
+        """
+        Builds the layout of the app: all the app components (drawer,
+        input/output tabs, header, footer, tutorial).
+        """
+        # tutorial widgets
+        self.tutorial = TutorialContainer()
+
+        # Inputs + process graph widgets
+        self.process_figures = ProcessFiguresContainer()
+
+        self.inputs = InputsContainer(self.process_launcher)
+
+        self.inputs.source_data_file_selector.observe(
+            self._set_source_data_file,
+            names="v_model",
+        )
+        self.inputs.process_selection_switch.observe(
+            self._switch_process,
+            names="v_model",
+        )
+        self.inputs.launch_button.on_event("click", self._launch_process)
+
+        self.output_figures = OutputFiguresContainer()
+
+        self.main_content = v.Container(
+            class_="pt-0",
+            fluid=True,
+            fill_height=True,
+        )
+
+        self.graphs_tabs = v.Tabs(
+            v_model="inputs",
+            align_tabs="center",
+            grow=True,
+            hide_slider=True,
+            children=[
+                v.Tab(
+                    value="inputs",
+                    children=["Inputs"],
+                ),
+                v.Tab(
+                    value="outputs",
+                    children=["Outputs"],
+                ),
+            ],
+        )
+
+        self.graphs_window = v.Window(
+            v_model="inputs",
+            children=[
+                v.WindowItem(
+                    value="inputs",
+                    children=[
+                        v.Divider(),
+                        v.Spacer(),
+                        self.process_figures,
+                    ],
+                ),
+                v.WindowItem(
+                    value="outputs",
+                    children=[
+                        v.Divider(),
+                        v.Spacer(),
+                        self.output_figures,
+                    ],
+                ),
+            ],
+        )
+
+        self.graphs = v.Container(
+            fluid=True,
+            children=[
+                self.graphs_tabs,
+                self.graphs_window,
+            ],
+        )
+
+        self.graphs_tabs.observe(
+            self._switch_tab,
+            names="v_model",
+        )
+
+        self.header = Header()
+        self.header.fast_oad_logo.on_event("click", lambda *args: self._to_tutorial())
+        self.header.open_drawer_button.on_event(
+            "click",
+            self._open_or_close_drawer,
+        )
+        self.header.clear_all_button.button.on_event(
+            "click",
+            self._clear_all_files,
+        )
+
+        self.drawer = Drawer()
+        self.drawer.close_drawer_button.on_event(
+            "click",
+            self._open_or_close_drawer,
+        )
+
+        self.footer = Footer()
+        self.footer.start_button.on_event("click", lambda *args: self._to_main())
+
+        self.to_outputs_button = v.Btn(
+            color="primary",
+            children=[
+                "Outputs",
+                v.Icon(class_="ps-2", children=["mdi-angle-right"]),
+            ],
+        )
+
+        self.to_inputs_button = v.Btn(
+            color="primary",
+            children=[
+                v.Icon(class_="pe-2", children=["mdi-angle-left"]),
+                "Inputs",
+            ],
+        )
+
+        self.navigation_buttons = v.Row(
+            class_="mx-6 mt-5",
+        )
+
+        # Padding column to avoid having the main content behind
+        # the drawer when expanded
+        self.padding_column = v.Col(
+            cols="1",
+            style_="padding: 100px 0 0 " + LEFT_PADDING + ";",
+            class_="hidden-md-and-down",
+        )
+
+        self.children = [
+            self.header,
+            self.drawer,
+            # Main content : to display graphs
+            v.Html(
+                tag="main",
+                class_="v-main",
+                children=[
+                    v.Row(
+                        style_="padding: " + TOP_PADDING + " 0 0 0;",
+                    ),
+                    v.Row(
+                        no_gutters=True,
+                        children=[
+                            self.padding_column,
+                            v.Col(
+                                children=[
+                                    v.Row(
+                                        children=[
+                                            self.main_content,
+                                        ],
+                                    ),
+                                ],
+                            ),
+                        ],
+                    ),
+                ],
+            ),
+            self.footer,
+        ]
+
+    def _switch_process(self, change):
+        """
+        Switch display between MDA and MDO depending on process selection
+        button state.
+
+        To be called with "observe" method of a widget.
+        """
+        data = change["new"]
+
+        # If the button toggle is on 1, switch to MDO
+        if data == "MDO":
+            self.is_MDO = True
+            self.inputs.to_mdo()
+            self.process_figures.to_mdo()
+
+        else:
+            self.is_MDO = False
+            self.inputs.to_mda()
+            self.process_figures.to_mda()
+
+    def _to_process_computation(self):
+        """
+        When a process is on-going, blocks the inputs and set a loading screen.
+        """
+        self.inputs.disable()
+        for tab in self.graphs_tabs.children:
+            tab.disabled = True
+
+        # Show a loading widget to make it apparent that a computation is
+        # underway.
+        self.process_figures.set_loading("Setting up and running")
+
+    def _to_process_results(self):
+        """
+        Re-enables input widgets after the end of a MDA/MDO process.
+        """
+        self.inputs.enable()
+        for tab in self.graphs_tabs.children:
+            tab.disabled = False
+        if self.is_MDO:
+            snackbar_to_open = self.process_figures.mdo_end_snackbar
+        elif self.process_launcher.get_mda_success():
+            snackbar_to_open = self.process_figures.mda_success_snackbar
+        else:
+            snackbar_to_open = self.process_figures.mda_failure_snackbar
+        self.process_figures.open_snackbar(snackbar_to_open)
+        # This resets the view to what was displayed before the run was launched.
+        self.process_figures._change_display(
+            {"new": self.process_figures._display_selection_buttons.v_model}
+        )
+
+    def _launch_process(self, widget, event, data):
+        """
+        Retrieves the user inputs from the drawer and launch the selected
+        process.
+
+        To be called with "on_event" method of a widget.
+        """
+        self._to_process_computation()
+        if self.is_MDO:
+            self.inputs.retrieve_mdo_inputs()
+        else:
+            self.inputs.retrieve_mda_inputs()
+        self.process_launcher.launch_processes(is_mdo=self.is_MDO)
+        self._to_process_results()
+
+    def _set_source_data_file(self, change):
+        """
+        Sets the reference file name to use
+
+        To be called with "observe" method of a widget.
+        """
+        self.inputs.set_initial_value_mda(change["new"])
+
+    def _open_or_close_drawer(self, widget, event, data):
+        """
+        Opens or closes the input drawer depending on its actual state.
+
+        To be called with "on_event" method of a widget.
+        """
+        self.drawer.v_model = not self.drawer.v_model
+
+    def _clear_all_files(self, widget, event, data):
+        """
+        Clear all files contained in "workdir", in subdirectories "inputs"
+        and "outputs", that are not the files of the reference aircraft.
+        Also makes the user come back to source selection.
+
+        The subdirectories of workdir are not deleted in the process.
+        """
+        # Gets back to source file selection
+        self._to_tutorial()
+        # Clears the output selection
+        self.output_figures.output_selection.v_model = []
+        self.output_figures.hide_graphs()
+
+        PathManager.clear_all_files()