RCAIDE-GUI 1.0.0__py3-none-any.whl

tabs/__init__.py

@@ -0,0 +1,10 @@
+# RCAIDE_GUI/tabs/__init__.py
+from .tab_widget import * 
+from . import aircraft_configs
+from . import analysis
+from . import geometry
+from . import home
+from . import mission
+from . import solve
+from . import visualize_geometry
+

tabs/aircraft_configs/__init__.py

@@ -0,0 +1,3 @@
+# RCAIDE_GUI/tabs/aircraft_configs/__init__.py
+ 
+from .aircraft_configs import * 

tabs/aircraft_configs/aircraft_configs.py

@@ -0,0 +1,301 @@
+# RCAIDE_GUI/tabs/aircraft_configs/aircraft_configs.py
+
+import RCAIDE
+from RCAIDE.Library.Components.Configs.Config import Config
+
+from tabs import TabWidget
+from utilities import Units
+from common_widgets import DataEntryWidget
+import rcaide_io
+
+from PyQt6.QtCore import QTimer
+from PyQt6.QtWidgets import (
+    QTreeWidgetItem, QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QTreeWidget,
+    QLabel, QLineEdit, QCheckBox, QSpacerItem, QSizePolicy, QScrollArea, QGroupBox,
+    QMessageBox, QInputDialog
+)
+
+
+class AircraftConfigsWidget(TabWidget):
+    def __init__(self):
+        super().__init__()
+        self._cfg_widgets  = {}   # config tag → {name_edit, cs_block, prop_block, gear_check}
+        self._selected_tag = None
+
+        base_layout = QHBoxLayout()
+
+        tree_layout = QVBoxLayout()
+        self.tree = QTreeWidget()
+        self.tree.setHeaderLabels(["Configuration Tree"])
+        self.root_item = QTreeWidgetItem(["Aircraft Configurations"])
+        self.tree.addTopLevelItem(self.root_item)
+        self.tree.itemClicked.connect(self.on_tree_item_clicked)
+        tree_layout.addWidget(self.tree)
+
+        self.main_layout = QVBoxLayout()
+        self.main_layout.addWidget(QLabel("<b>All Configurations</b>"))
+
+        self.scroll = QScrollArea()
+        self.scroll.setWidgetResizable(True)
+        self.scroll_container = QWidget()
+        self.scroll_layout = QVBoxLayout(self.scroll_container)
+        self.scroll.setWidget(self.scroll_container)
+        self.main_layout.addWidget(self.scroll)
+
+        button_layout = QHBoxLayout()
+        new_btn = QPushButton("New Config")
+        new_btn.clicked.connect(self.new_configuration)
+        button_layout.addWidget(new_btn)
+        save_btn = QPushButton("Save Config")
+        save_btn.clicked.connect(self.save_data)
+        button_layout.addWidget(save_btn)
+        delete_btn = QPushButton("Delete Config")
+        delete_btn.clicked.connect(self.delete_data)
+        button_layout.addWidget(delete_btn)
+        self.main_layout.addLayout(button_layout)
+
+        base_layout.addLayout(tree_layout, 3)
+        base_layout.addLayout(self.main_layout, 7)
+        self.setLayout(base_layout)
+
+        QTimer.singleShot(0, self.update_layout)
+
+    # ------------------------------------------------------------------
+    #  Vehicle traversal helpers
+    # ------------------------------------------------------------------
+
+    def _cs_names(self):
+        names = []
+        for wing in getattr(rcaide_io.vehicle, 'wings', []):
+            for cs in getattr(wing, 'control_surfaces', []):
+                tag = getattr(cs, 'tag', None)
+                if tag and tag not in names:
+                    names.append(tag)
+        return sorted(names)
+
+    def _prop_names(self):
+        names = []
+        for network in getattr(rcaide_io.vehicle, 'networks', []):
+            for prop in getattr(network, 'propulsors', []):
+                tag = getattr(prop, 'tag', None)
+                if tag and tag not in names:
+                    names.append(tag)
+        return sorted(names)
+
+    def _get_cs_deflection(self, config, cs_name):
+        for wing in getattr(config, 'wings', []):
+            for cs in getattr(wing, 'control_surfaces', []):
+                if getattr(cs, 'tag', None) == cs_name:
+                    return getattr(cs, 'deflection', 0.0)
+        return 0.0
+
+    def _set_cs_deflection(self, config, cs_name, angle):
+        for wing in getattr(config, 'wings', []):
+            for cs in getattr(wing, 'control_surfaces', []):
+                if getattr(cs, 'tag', None) == cs_name:
+                    cs.deflection = angle
+                    return
+
+    def _get_gear_extended(self, config):
+        for gear in getattr(config, 'landing_gears', []):
+            if getattr(gear, 'gear_extended', False):
+                return True
+        return False
+
+    def _set_gear_extended(self, config, value):
+        for gear in getattr(config, 'landing_gears', []):
+            gear.gear_extended = value
+
+    def _get_prop_active(self, config, prop_name):
+        for network in getattr(config, 'networks', []):
+            for prop in getattr(network, 'propulsors', []):
+                if getattr(prop, 'tag', None) == prop_name:
+                    return getattr(prop, 'active', True)
+        return True
+
+    def _set_prop_active(self, config, prop_name, value):
+        for network in getattr(config, 'networks', []):
+            for prop in getattr(network, 'propulsors', []):
+                if getattr(prop, 'tag', None) == prop_name:
+                    if hasattr(prop, 'active'):
+                        prop.active = bool(value)
+                    return
+
+    # ------------------------------------------------------------------
+    #  Layout
+    # ------------------------------------------------------------------
+
+    def update_layout(self):
+        cs_names   = self._cs_names()
+        prop_names = self._prop_names()
+        cs_labels   = [(f"{n} Deflection", Units.Angle)   for n in cs_names]
+        prop_labels = [(f"{n} Enabled",    Units.Boolean) for n in prop_names]
+
+        self._cfg_widgets.clear()
+        while self.scroll_layout.count():
+            w = self.scroll_layout.takeAt(0).widget()
+            if w:
+                w.deleteLater()
+        self.root_item.takeChildren()
+
+        configs = rcaide_io.rcaide_configs
+        for cfg_tag, config in configs.items():
+            if not hasattr(config, 'tag'):
+                continue
+            name = config.tag
+
+            group  = QGroupBox(name)
+            layout = QVBoxLayout(group)
+
+            name_row = QHBoxLayout()
+            name_row.addWidget(QLabel("Config Name:"))
+            name_edit = QLineEdit(name)
+            name_row.addWidget(name_edit)
+            layout.addLayout(name_row)
+
+            layout.addWidget(QLabel("<b>Control Surfaces</b>"))
+            cs_block = None
+            if cs_labels:
+                cs_block = DataEntryWidget(cs_labels)
+                cs_block.load_data({
+                    f"{n} Deflection": [self._get_cs_deflection(config, n), 0]
+                    for n in cs_names
+                })
+                layout.addWidget(cs_block)
+            else:
+                layout.addWidget(QLabel("<i>No control surfaces defined.</i>"))
+
+            layout.addWidget(QLabel("<b>Propulsors</b>"))
+            prop_block = None
+            if prop_labels:
+                prop_block = DataEntryWidget(prop_labels)
+                prop_block.load_data({
+                    f"{n} Enabled": [self._get_prop_active(config, n), 0]
+                    for n in prop_names
+                })
+                layout.addWidget(prop_block)
+            else:
+                layout.addWidget(QLabel("<i>No propulsors defined.</i>"))
+
+            gear_check = QCheckBox("Landing Gear Deployed")
+            gear_check.setChecked(self._get_gear_extended(config))
+            layout.addWidget(gear_check)
+
+            self._cfg_widgets[name] = {
+                "name":      name_edit,
+                "cs":        cs_block,
+                "prop":      prop_block,
+                "gear":      gear_check,
+                "orig_tag":  cfg_tag,
+            }
+
+            self.scroll_layout.addWidget(group)
+            self.root_item.addChild(QTreeWidgetItem([name]))
+
+        self.scroll_layout.addSpacerItem(
+            QSpacerItem(0, 0, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+        )
+        self.tree.expandAll()
+
+    def on_tree_item_clicked(self, item, _):
+        idx  = self.root_item.indexOfChild(item)
+        tags = list(self._cfg_widgets.keys())
+        self._selected_tag = tags[idx] if 0 <= idx < len(tags) else None
+
+    # ------------------------------------------------------------------
+    #  CRUD
+    # ------------------------------------------------------------------
+
+    def new_configuration(self):
+        name, ok = QInputDialog.getText(self, "New Configuration", "Configuration name:")
+        if not ok:
+            return
+        name = name.strip()
+        if not name:
+            QMessageBox.warning(self, "Invalid Name", "Configuration name cannot be empty.")
+            return
+        if any(getattr(c, 'tag', '') == name for _, c in rcaide_io.rcaide_configs.items()):
+            QMessageBox.warning(self, "Duplicate Name", "Configuration name already exists.")
+            return
+
+        config     = Config(rcaide_io.vehicle)
+        config.tag = name
+        rcaide_io.rcaide_configs.append(config)
+        self._selected_tag = name
+        self.update_layout()
+
+    def save_data(self):
+        new_configs = Config.Container()
+        for name, w in self._cfg_widgets.items():
+            orig_tag = w["orig_tag"]
+            try:
+                config = rcaide_io.rcaide_configs[orig_tag]
+            except (KeyError, TypeError):
+                continue
+
+            new_name   = w["name"].text().strip() or name
+            config.tag = new_name
+
+            if w["cs"]:
+                for label, val in w["cs"].get_values().items():
+                    if label.endswith(" Deflection"):
+                        cs_name = label[: -len(" Deflection")]
+                        angle   = val[0] if isinstance(val, (list, tuple)) else val
+                        self._set_cs_deflection(config, cs_name, angle)
+
+            if w["prop"]:
+                for label, val in w["prop"].get_values().items():
+                    if label.endswith(" Enabled"):
+                        prop_name = label[: -len(" Enabled")]
+                        active    = val[0] if isinstance(val, (list, tuple)) else val
+                        self._set_prop_active(config, prop_name, active)
+
+            self._set_gear_extended(config, w["gear"].isChecked())
+            new_configs.append(config)
+
+        rcaide_io.rcaide_configs   = new_configs
+        rcaide_io.propulsor_names  = _collect_propulsor_names(rcaide_io.vehicle)
+        self.update_layout()
+        QMessageBox.information(self, "Saved", "Aircraft configurations saved.")
+
+    def delete_data(self):
+        if self._selected_tag is None:
+            return
+        orig_tag = (self._cfg_widgets.get(self._selected_tag) or {}).get("orig_tag")
+        key = orig_tag or self._selected_tag
+        try:
+            del rcaide_io.rcaide_configs[key]
+        except (KeyError, TypeError, AttributeError):
+            pass
+        self._selected_tag = None
+        self.update_layout()
+
+
+# ------------------------------------------------------------------------------
+#  Module-level helpers
+# ------------------------------------------------------------------------------
+
+def _collect_propulsor_names(vehicle):
+    names = [[]]
+    for network in getattr(vehicle, 'networks', []):
+        for prop in getattr(network, 'propulsors', []):
+            names[0].append(prop.tag)
+    return names
+
+
+def build_rcaide_configs_from_geometry():
+    """
+    Return the current RCAIDE Config.Container, collecting propulsor names as a
+    side effect.  Raises RuntimeError if no vehicle or configs are available.
+    """
+    if rcaide_io.vehicle is None:
+        raise RuntimeError("No geometry data available")
+    if not rcaide_io.rcaide_configs:
+        raise RuntimeError("No aircraft configurations available")
+
+    rcaide_io.propulsor_names = _collect_propulsor_names(rcaide_io.vehicle)
+    return rcaide_io.rcaide_configs
+
+
+def get_widget() -> QWidget:
+    return AircraftConfigsWidget()

tabs/analysis/__init__.py

@@ -0,0 +1,4 @@
+# RCAIDE_GUI/tabs/analysis/__init__.py
+
+from .analysis import *
+from . import widgets

tabs/analysis/analysis.py

@@ -0,0 +1,92 @@
+# RCAIDE_GUI/tabs/analysis/analysis.py
+
+# RCAIDE imports
+import RCAIDE
+
+# RCAIDE-GUI imports
+from tabs.mission.widgets import MissionAnalysisWidget
+from tabs.analysis.widgets import *
+from tabs import TabWidget
+from utilities import create_scroll_area
+import rcaide_io
+
+# PyQt imports
+from PyQt6.QtCore import Qt, QTimer
+from PyQt6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QTreeWidget, \
+    QTreeWidgetItem, QHeaderView, QPushButton, QLabel, QGroupBox
+
+# ------------------------------------------------------------------------------
+# Analysis Widget
+# ------------------------------------------------------------------------------
+class AnalysisWidget(TabWidget):
+    def __init__(self):
+        super().__init__()
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(10, 10, 10, 10)
+
+        analyses_box = QGroupBox("Analyses Setup")
+        analyses_v = QVBoxLayout(analyses_box)
+
+        self.save_notice = QLabel("")
+        self.save_notice.setVisible(False)
+        self.save_notice.setStyleSheet(
+            "color:#10351e; background:#9fe3b5; border:1px solid #2d8a57; "
+            "border-radius:4px; padding:6px 10px; font-weight:600;"
+        )
+        analyses_v.addWidget(self.save_notice)
+
+        self.analysis_content = MissionAnalysisWidget()
+        analyses_v.addWidget(self.analysis_content)
+
+        layout.addWidget(analyses_box)
+
+        btn_row = QHBoxLayout()
+        self.save_btn = QPushButton("Save Analyses")
+        self.save_btn.setStyleSheet("background-color:#141b29; color:#e5f0ff; padding: 8px;")
+        self.save_btn.clicked.connect(self.save_analyses_to_values)
+
+        btn_row.addStretch()
+        btn_row.addWidget(self.save_btn)
+
+        layout.addLayout(btn_row)
+
+    def save_analyses_to_values(self):
+        # Build the RCAIDE analyses from the current UI state and store them in `values`.
+        self.analysis_content.save_analyses()
+        saved_configs = list(getattr(values, "rcaide_analyses", {}).keys())
+        # Show a short in-app confirmation so the user does not have to rely on terminal output.
+        self.save_notice.setText(
+            f"Analyses saved successfully for {len(saved_configs)} configuration(s)."
+        )
+        self.save_notice.setVisible(True)
+        QTimer.singleShot(2500, lambda: self.save_notice.setVisible(False))
+
+        # Print a readable summary of what was written into `rcaide_io.rcaide_analyses`.
+        print("\n[Analyses Saved]")
+        print(f"Configs: {len(saved_configs)}")
+        print(f"Names: {', '.join(saved_configs) if saved_configs else 'None'}")
+
+        for config_name, analysis in getattr(values, "rcaide_analyses", {}).items():
+            try:
+                entries = list(analysis)
+            except TypeError:
+                entries = []
+
+            entry_labels = [
+                getattr(entry, "tag", entry.__class__.__name__)
+                for entry in entries
+            ]
+            print(f"- {config_name}")
+            print(f"  Entries: {len(entry_labels)}")
+            print(f"  Tags: {', '.join(entry_labels) if entry_labels else 'None'}")
+
+    def load_from_values(self):
+        if hasattr(self.analysis_content, "load_values"):
+            self.analysis_content.load_values()
+
+    def get_data(self):
+        return self.analysis_content.get_data()
+
+def get_widget() -> QWidget:
+    return AnalysisWidget()

tabs/analysis/widgets/__init__.py

@@ -0,0 +1,13 @@
+# RCAIDE_GUI/tabs/analysis/widgets/__init__.py
+
+from tabs.analysis.widgets.analysis_data_widget import AnalysisDataWidget
+from tabs.analysis.widgets.aerodynamics_widget  import AerodynamicsWidget
+from tabs.analysis.widgets.atmosphere_widget    import AtmosphereWidget
+from tabs.analysis.widgets.costs_widget         import CostsWidget
+from tabs.analysis.widgets.energy_widget        import EnergyWidget
+from tabs.analysis.widgets.aeroacoustics_widget import AeroacousticsWidget
+from tabs.analysis.widgets.planets_widget       import PlanetsWidget
+from tabs.analysis.widgets.propulsion_widget    import PropulsionWidget
+from tabs.analysis.widgets.stability_widget     import StabilityWidget
+from tabs.analysis.widgets.weights_widget       import WeightsWidget
+from tabs.analysis.widgets.geometry_widget      import GeometryWidget

tabs/analysis/widgets/aeroacoustics_widget.py

@@ -0,0 +1,158 @@
+# RCAIDE_GUI/tabs/analysis/widgets/aeroacoustics_widget.py
+
+# Created: May 2023, M. Clarke
+# ------------------------------------------------------------------------------
+# Imports
+# ------------------------------------------------------------------------------
+# RCAIDE imports
+import RCAIDE
+
+# RCAIDE-GUI imports
+from utilities import create_line_bar, Units, set_data
+from tabs.analysis.widgets import AnalysisDataWidget
+from common_widgets import DataEntryWidget
+
+# PyQt imports
+from PyQt6.QtWidgets import QWidget, QLabel, QVBoxLayout, QComboBox
+
+# Python imports
+import json
+import os
+
+# ------------------------------------------------------------------------------
+# Aeroacoustics Widget
+# ------------------------------------------------------------------------------
+class AeroacousticsWidget(AnalysisDataWidget):
+    def __init__(self):
+        super(AeroacousticsWidget, self).__init__()
+        self.main_layout = QVBoxLayout()
+
+        self.main_layout.addWidget(QLabel("<b>Acoustics</b>"))
+        self.main_layout.addWidget(create_line_bar())
+
+        self.analysis_selector = QComboBox()
+        self.analysis_selector.addItems(self.analyses)
+        self.analysis_selector.currentIndexChanged.connect(
+            self.on_analysis_change)
+        self.main_layout.addWidget(self.analysis_selector)
+
+        self.data_entry_widget = DataEntryWidget(self.data_units_labels[0])
+        self.main_layout.addWidget(self.data_entry_widget)
+
+        _root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+        _defaults_path = os.path.join(_root, "app_data", "defaults", "aeroacoustics_analysis.json")
+        with open(_defaults_path, "r") as defaults:
+            self.defaults = json.load(defaults)
+
+        self.data_entry_widget.load_data(self.defaults[0])
+        self.main_layout.addWidget(create_line_bar())
+        self.setLayout(self.main_layout)
+
+    def on_analysis_change(self, index): 
+        assert self.main_layout is not None
+
+        self.main_layout.removeWidget(self.data_entry_widget)
+        self.data_entry_widget = DataEntryWidget(self.data_units_labels[index])
+        self.data_entry_widget.load_data(self.defaults[index])
+        # self.main_layout.addWidget(self.data_entry_widget)
+        self.main_layout.insertWidget(
+            self.main_layout.count() - 1, self.data_entry_widget)
+
+    def create_analysis(self, vehicle):
+        analysis_num = self.analysis_selector.currentIndex()
+        if analysis_num == 0:
+            aeroacoustics = RCAIDE.Framework.Analyses.Aeroacoustics.Semi_Empirical()
+        else:
+            aeroacoustics = RCAIDE.Framework.Analyses.Aeroacoustics.Physics_Based()
+
+        settings  = aeroacoustics.settings
+        values_si = self.data_entry_widget.get_values_si()
+
+        for data_unit_label in self.data_units_labels[analysis_num]:
+            if len(data_unit_label) < 3:
+                continue
+
+            rcaide_label = data_unit_label[-1]
+            user_label = data_unit_label[0]
+            set_data(settings, rcaide_label, values_si[user_label])
+
+        phi_upper_bound = values_si["Noise Hemisphere Phi Upper Bound"][0]
+        phi_lower_bound = values_si["Noise Hemisphere Phi Lower Bound"][0]
+
+        settings.noise_hemisphere_phi_angle_bounds = [
+            phi_lower_bound, phi_upper_bound]
+
+        theta_upper_bound = values_si["Noise Hemisphere Theta Upper Bound"][0]
+        theta_lower_bound = values_si["Noise Hemisphere Theta Lower Bound"][0]
+
+        settings.noise_hemisphere_theta_angle_bounds = [
+            theta_lower_bound, theta_upper_bound]
+ 
+        return aeroacoustics
+    
+    def get_values(self):
+        data = self.data_entry_widget.get_values()
+        data["analysis_num"] = self.analysis_selector.currentIndex()
+        return data
+    
+    def load_values(self, values):
+        super().load_values(values)
+        self.analysis_selector.setCurrentIndex(values["analysis_num"])
+        self.on_analysis_change(values["analysis_num"])
+        self.data_entry_widget.load_data(values)
+
+    data_units_labels = [
+        [
+            ("Print Noise Output", Units.Boolean, "print_noise_output"),
+            ("Mean Sea Level Altitude", Units.Boolean, "mean_sea_level_altitude"),
+            ("Aircraft Departure Location", Units.Position,
+             "aircraft_departure_location"),
+            ("Aircraft Destination Location", Units.Position,
+             "aircraft_destination_location"),
+            ("Microphone X Resolution", Units.Count, "microphone_x_resolution"),
+            ("Microphone Y Resolution", Units.Count, "microphone_y_resolution"),
+            # TODO ("Microphone X Stencil", Units.Length),
+            # TODO ("Microphone Y Stencil", Units.Length),
+            ("Microphone Min X", Units.Length, "microphone_min_x"),
+            ("Microphone Max X", Units.Length, "microphone_max_x"),
+            ("Microphone Min Y", Units.Length, "microphone_min_y"),
+            ("Microphone Max Y", Units.Length, "microphone_max_y"),
+            ("Noise Hemisphere", Units.Boolean, "noise_hemisphere"),
+            ("Noise Hemisphere Radius", Units.Length, "noise_hemisphere_radius"),
+            ("Noise Hemisphere Microphone Resolution", Units.Count,
+             "noise_hemisphere_microphone_resolution"),
+            ("Noise Hemisphere Phi Upper Bound", Units.Angle),
+            ("Noise Hemisphere Phi Lower Bound", Units.Angle),
+            ("Noise Hemisphere Theta Upper Bound", Units.Angle),
+            ("Noise Hemisphere Theta Lower Bound", Units.Angle),
+        ],
+        [
+            ("Flyover", Units.Boolean, "flyover"),
+            ("Approach", Units.Boolean, "approach"),
+            ("Sideline", Units.Boolean, "sideline"),
+            ("Sideline X Position", Units.Boolean, "sideline_x_position"),
+            ("Print Noise Output", Units.Boolean, "print_noise_output"),
+            ("Mean Sea Level Altitude", Units.Boolean, "mean_sea_level_altitude"),
+            ("Aircraft Departure Location", Units.Position,
+             "aircraft_departure_location"),
+            ("Aircraft Destination Location", Units.Position,
+             "aircraft_destination_location"),
+            ("Microphone X Resolution", Units.Count, "microphone_x_resolution"),
+            ("Microphone Y Resolution", Units.Count, "microphone_y_resolution"),
+            # TODO ("Microphone X Stencil", Units.Length),
+            # TODO ("Microphone Y Stencil", Units.Length),
+            ("Microphone Min X", Units.Length, "microphone_min_x"),
+            ("Microphone Max X", Units.Length, "microphone_max_x"),
+            ("Microphone Min Y", Units.Length, "microphone_min_y"),
+            ("Microphone Max Y", Units.Length, "microphone_max_y"),
+            ("Noise Hemisphere", Units.Boolean, "noise_hemisphere"),
+            ("Noise Hemisphere Radius", Units.Length, "noise_hemisphere_radius"),
+            ("Noise Hemisphere Microphone Resolution", Units.Count,
+             "noise_hemisphere_microphone_resolution"),
+            ("Noise Hemisphere Phi Upper Bound", Units.Angle),
+            ("Noise Hemisphere Phi Lower Bound", Units.Angle),
+            ("Noise Hemisphere Theta Upper Bound", Units.Angle),
+            ("Noise Hemisphere Theta Lower Bound", Units.Angle),
+        ]
+    ]
+    analyses = ["Semi Empirical", "Physics-Based"]