RCAIDE-GUI 1.0.0__py3-none-any.whl

tabs/solve/plots/thermal_management/plot_wavy_channel_conditions.py

@@ -0,0 +1,161 @@
+# RCAIDE/Library/Plots/Thermal_Management/plot_wavy_channel_conditions.py
+# 
+# 
+# Created:  Sep 2024, S. Shekar
+
+# ----------------------------------------------------------------------------------------------------------------------
+#  IMPORT
+# ----------------------------------------------------------------------------------------------------------------------  
+
+from RCAIDE.Framework.Core import Units
+from RCAIDE.Library.Plots.Common import set_axes, plot_style
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+import numpy as np 
+
+# ----------------------------------------------------------------------------------------------------------------------
+#   plot_wavy_channel_conditions
+# ----------------------------------------------------------------------------------------------------------------------   
+def plot_wavy_channel_conditions(wavy_channel, results, coolant_line,
+                             save_figure = False,
+                             show_legend = True,
+                             save_filename = "Wavy_Channel_Conditions",
+                             file_type = ".png",
+                             width = 11, height = 7):
+    """
+    Creates a multi-panel visualization of wavy channel heat exchanger performance.
+
+    Parameters
+    ----------
+    wavy_channel : Component
+        Wavy channel heat exchanger component containing:
+            - tag : str
+                Unique identifier for the heat exchanger
+            
+    results : Results
+        RCAIDE results data structure containing:
+            - segments[i].conditions.frames.inertial.time[:,0]
+                Time history for each segment
+            - segments[i].conditions.energy.coolant_lines[coolant_line.tag][wavy_channel.tag]
+                Heat exchanger data containing:
+                    - outlet_coolant_temperature[:,0]
+                        Coolant outlet temperature in K
+                    - coolant_mass_flow_rate[:,0]
+                        Coolant flow rate in kg/s
+                    - power[:,0]
+                        Heat transfer rate in watts
+                    
+    coolant_line : Component
+        Coolant line component containing:
+            - tag : str
+                Unique identifier for the coolant circuit
+            
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    show_legend : bool, optional
+        Flag to display segment legend (default: True)
+        
+    save_filename : str, optional
+        Name of file for saved figure (default: "Wavy_Channel_Conditions")
+        
+    file_type : str, optional
+        File extension for saved figure (default: ".png")
+        
+    width : float, optional
+        Figure width in inches (default: 11)
+        
+    height : float, optional
+        Figure height in inches (default: 7)
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+        Handle to the generated figure containing three subplots
+        
+    Notes
+    -----
+    Creates visualization showing:
+        * Thermal performance metrics
+        * Flow conditions
+        * Heat transfer characteristics
+        * Time history for each segment
+    
+    **Definitions**
+    
+    'Wavy Channel'
+        Heat exchanger with sinusoidal flow paths
+    'Hydraulic Diameter'
+        4 × (flow area) / (wetted perimeter)
+    'Heat Transfer Rate'
+        Rate of thermal energy transfer
+    'Mass Flow Rate'
+        Mass of fluid flowing per unit time
+    
+    See Also
+    --------
+    RCAIDE.Library.Plots.Thermal_Management.plot_thermal_management_performance : Overall system performance
+    RCAIDE.Library.Plots.Thermal_Management.plot_cross_flow_heat_exchanger_conditions : Cross-flow heat exchanger analysis
+    """
+    
+    # get plotting style 
+    ps      = plot_style()  
+
+    parameters = {'axes.labelsize': ps.axis_font_size,
+                  'xtick.labelsize': ps.axis_font_size,
+                  'ytick.labelsize': ps.axis_font_size,
+                  'axes.titlesize': ps.title_font_size}
+    plt.rcParams.update(parameters)
+     
+    # get line colors for plots 
+    line_colors   = cm.inferno(np.linspace(0,0.9,len(results.segments)))
+    
+    fig = plt.figure('Identical_'+ save_filename)
+    fig.set_size_inches(width,height) 
+    axis_1 = plt.subplot(2,2,1)
+    axis_2 = plt.subplot(2,2,2) 
+    axis_3 = plt.subplot(2,2,3)
+
+    for network in results.segments[0].analyses.vehicle.networks: 
+        busses  = network.busses 
+        for bus in busses:
+            for b_i, battery in enumerate(bus.battery_modules):
+                if b_i == 0 or bus.identical_battery_modules == False:
+                    for i in range(len(results.segments)): 
+                        time                            = results.segments[i].conditions.frames.inertial.time[:,0] / Units.min    
+                        wavy_channel_conditions         = results.segments[i].conditions.energy.coolant_lines[coolant_line.tag][wavy_channel.tag]
+                        outlet_coolant_temperature      = wavy_channel_conditions.outlet_coolant_temperature[:,0]
+                        coolant_mass_flow_rate          = wavy_channel_conditions.coolant_mass_flow_rate[:,0]
+                        power                           = wavy_channel_conditions.power[:,0]       
+                
+                        if i == 0:                
+                            axis_1.plot(time, outlet_coolant_temperature, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width, label = wavy_channel.tag)
+                        else:
+                            axis_1.plot(time, outlet_coolant_temperature, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_1.set_ylabel(r'Coolant Temp. (K)') 
+                        set_axes(axis_1)     
+                         
+                        axis_2.plot(time, coolant_mass_flow_rate, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_2.set_ylabel(r'Coolant $\dot{m}$ (kg/s)')
+                        set_axes(axis_2) 
+                 
+                        axis_3.plot(time, power, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_3.set_ylabel(r'HAS Power (W)')
+                        axis_3.set_xlabel(r'Time (mins)')
+                        set_axes(axis_3)
+        
+    if show_legend:          
+        leg =  fig.legend(bbox_to_anchor=(0.5, 0.95), loc='upper center', ncol = 4) 
+        leg.set_title('Flight Segment', prop={'size': ps.legend_font_size, 'weight': 'heavy'})     
+    
+    # Adjusting the sub-plots for legend 
+    fig.tight_layout()
+    fig.subplots_adjust(top=0.8) 
+    
+    # set title of plot 
+    title_text   = 'Wavy_Channel_Properties'       
+    fig.suptitle(title_text) 
+    
+    if save_figure:
+        plt.savefig(wavy_channel.tag + file_type)    
+    return fig 

tabs/solve/plots/weights/__init__.py

@@ -0,0 +1,4 @@
+# RCAIDE_GUI/tabs/solve/plots/weights/__init__.py
+
+from .plot_weight_breakdown import plot_weight_breakdown
+from .plot_load_diagram     import plot_load_diagram

tabs/solve/plots/weights/plot_load_diagram.py

@@ -0,0 +1,163 @@
+# RCAIDE/Library/Plots/Weights/plot_load_diagram.py
+# 
+# 
+# Created:  Aug 2025, M. Clarke
+
+# ----------------------------------------------------------------------------------------------------------------------
+#  IMPORT
+# ----------------------------------------------------------------------------------------------------------------------  
+from RCAIDE.Framework.Core import Units
+from RCAIDE.Library.Plots.Common import set_axes, plot_style
+import matplotlib.pyplot as plt
+from scipy.spatial import ConvexHull
+from shapely.geometry import Polygon
+import matplotlib.cm as cm
+from scipy.interpolate import griddata
+import matplotlib.tri as tri
+import numpy as np 
+
+# ----------------------------------------------------------------------------------------------------------------------
+#  PLOTS
+# ---------------------------------------------------------------------------------------------------------------------- 
+def plot_load_diagram(results,
+                      save_figure = False,
+                      show_legend = True,
+                      save_filename = "Aircraft_Loading_Trim_Dragram",
+                      file_type = ".png",
+                      width = 11, height = 7):
+    """
+    Creates a comprehensive aircraft loading diagram showing mass and center of gravity relationships.
+
+    Parameters
+    ----------
+    results : RCAIDE.Framework.Core.Data
+        Results from load and trim diagram analysis containing:
+            - loading_mass : numpy.ndarray
+                Aircraft mass for loading diagram [kg]
+            - loading_LEMAC_location : numpy.ndarray
+                LEMAC location as percentage of reference chord [%]
+            - aerodynamic_LEMAC_location : numpy.ndarray
+                LEMAC location for trim diagram [%]
+            - aerodynamic_mass : numpy.ndarray
+                Aircraft mass for trim diagram [kg]
+            - aerodynamic_static_margin : numpy.ndarray
+                Static margin values [unitless]
+            - MTOW : float
+                Maximum takeoff weight [kg]
+            - MLW : float
+                Maximum landing weight [kg]
+
+    Returns
+    -------
+    None
+        Creates and displays a matplotlib figure with the loading diagram
+
+    Notes
+    -----
+    This function generates a comprehensive aircraft loading diagram that visualizes
+    the relationship between aircraft mass, loading, and center of gravity position. The diagram
+    includes fuel loading curves, payload loading curves, weight limits, and stability
+    contours to provide a complete view of the aircraft's loading envelope.
+    
+    **Major Assumptions**
+        * Convex hull calculation is valid for the data points
+    
+    **Definitions**
+
+    'Loading Diagram'
+        Plot showing aircraft mass versus center of gravity position for different loading conditions.
+    
+    'Convex Hull'
+        Smallest convex polygon that contains all the data points.
+    
+    'Static Margin'
+        Distance between center of gravity and neutral point as percentage of reference chord.
+    
+    'LEMAC'
+        Leading Edge Mean Aerodynamic Chord reference point for center of gravity calculations.
+
+    See Also
+    --------
+    matplotlib.pyplot
+    scipy.spatial.ConvexHull
+    shapely.geometry.Polygon
+    """
+    
+    # get plotting style 
+    ps      = plot_style()  
+
+    parameters = {'axes.labelsize': ps.axis_font_size,
+                  'xtick.labelsize': ps.axis_font_size,
+                  'ytick.labelsize': ps.axis_font_size,
+                  'axes.titlesize': ps.title_font_size}
+    plt.rcParams.update(parameters)
+ 
+    fig   = plt.figure(save_filename)
+    fig.set_size_inches(width,height)
+    axis = fig.add_subplot(1,1,1)
+    
+    min_range = 0
+    max_range = 0
+    
+    # ------------------------------------------------------------------------    
+    # cumulative
+    # ------------------------------------------------------------------------ 
+    
+    # 1. Generate sample scattered data
+    points =  np.hstack((   np.atleast_2d(results.loading_LEMAC_location.flatten()).T,  np.atleast_2d(results.loading_mass.flatten()).T )) 
+    
+    # 2. Compute the convex hull
+    hull = ConvexHull(points)
+    
+    # 3. Extract the vertices of the hull in a counter-clockwise order
+    hull_points = points[hull.vertices]
+    
+    # 4. Create a Shapely Polygon from the hull vertices
+    # The vertices are already ordered, but Shapely can handle it
+    polygon = Polygon(hull_points) 
+    
+    # Plot the convex hull polygon boundary
+    x_hull, y_hull = polygon.exterior.xy
+    
+    axis.fill(x_hull, y_hull, color='grey', alpha=0.3, edgecolor='black', linewidth=2)
+    axis.plot(x_hull, y_hull, 'k-')
+
+    # ------------------------------------------------------------------------    
+    # Maximum Takeoff Weight line
+    # ------------------------------------------------------------------------
+    x_pts_MTOW = np.linspace(0, 100)
+    y_pts_MTOW = np.ones_like(x_pts_MTOW)  * results.MTOW
+    axis.plot(x_pts_MTOW, y_pts_MTOW, 'r-', label = 'MTOW') 
+    
+
+    # ------------------------------------------------------------------------    
+    # Maximum Landing Weight line
+    # ------------------------------------------------------------------------
+    x_pts_MLW = x_pts_MTOW
+    y_pts_MLW = np.ones_like(x_pts_MLW)  * results.MLW
+    axis.plot(x_pts_MLW, y_pts_MLW, 'r--', label = 'MLW')  
+
+    # ------------------------------------------------------------------------
+    # Stability Contours 
+    # ------------------------------------------------------------------------
+    SM_levels = np.linspace(-5, 100, 22)
+    CS   =  axis.contourf(results.aerodynamic_LEMAC_location, results.aerodynamic_mass, results.aerodynamic_static_margin*100, levels=SM_levels, cmap='viridis') 
+    CS2  =  axis.contour(results.aerodynamic_LEMAC_location, results.aerodynamic_mass, results.aerodynamic_static_margin*100, levels=SM_levels, colors='black') 
+    cbar = fig.colorbar(CS, ax=axis)
+    axis.clabel(CS2, fontsize=10)
+    cbar.ax.set_ylabel('Static Margin', rotation =  90)    
+    
+    # ------------------------------------------------------------------------    
+    # Axis Items
+    # ------------------------------------------------------------------------     
+    axis.set_xlim(0, 100)
+    axis.legend(loc='upper right')
+    axis.set_xlabel(r'$X_{CG}$ (%MAC)')
+    axis.set_ylabel('Mass (kg)')
+    axis.grid(True)
+    fig.tight_layout()
+     
+    if save_figure:
+        plt.savefig(save_filename + file_type)       
+                                  
+    return

tabs/solve/plots/weights/plot_weight_breakdown.py

@@ -0,0 +1,164 @@
+# RCAIDE/Library/Plots/Weights/plot_weight_breakdown.py
+# 
+# 
+# Created:  Jul 2023, M. Clarke 
+
+# ----------------------------------------------------------------------------------------------------------------------
+#  IMPORT
+# ----------------------------------------------------------------------------------------------------------------------
+import RCAIDE 
+import numpy as np     
+import plotly.express as px 
+import pandas as pd
+
+# ----------------------------------------------------------------------------------------------------------------------
+#  PLOTS
+# ----------------------------------------------------------------------------------------------------------------------   
+def plot_weight_breakdown(vehicle,
+                            save_figure    = False,
+                            show_figure    = True, 
+                            show_legend    = True, 
+                            save_filename  = "Weight_Breakdown",
+                            aircraft_name  = None,
+                            file_type      = ".png",
+                            width          = 10, height = 7.2): 
+  
+
+    """
+    Creates an interactive sunburst visualization of aircraft weight breakdown.
+
+    Parameters
+    ----------
+    vehicle : Vehicle
+        RCAIDE vehicle data structure containing:
+        
+        * weight_breakdown : Data
+            Hierarchical weight data with structure:
+                * zero_fuel_weight : float
+                    Aircraft weight without fuel
+                * max_takeoff : float
+                    Maximum takeoff weight
+                * systems : Data
+                    System weights containing:
+                        * total : float
+                            Total systems weight
+                        * [system_name] : float/Data
+                            Individual system weights/subcomponents
+                * fuel : float
+                    Total fuel weight
+                
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    show_figure : bool, optional
+        Flag to display interactive plot (default: True)
+        
+    show_legend : bool, optional
+        Flag to display weight legend (default: True) 
+        
+    save_filename : str, optional
+        Name of file for saved figure (default: "Weight_Breakdown")
+        
+    aircraft_name : str, optional
+        Name to display in plot title (default: None)
+        
+    file_type : str, optional
+        File extension for saved figure (default: ".png")
+        
+    width : float, optional
+        Figure width in inches (default: 10)
+        
+    height : float, optional
+        Figure height in inches (default: 7.2)
+
+    Returns
+    -------
+    fig : plotly.graph_objects.Figure
+        Handle to the generated figure containing:
+
+    Notes
+    -----
+    Creates visualization showing:
+        * Hierarchical weight breakdown
+        * Weight percentages
+        * Multi-level weight relationships
+        * Interactive exploration
+    
+    **Major Assumptions**
+        * All weights are positive
+        * Hierarchy is properly structured
+        * No duplicate component names
+        * Subcomponent weights sum to totals
+    
+    **Definitions**
+    
+    'Weight Breakdown'
+        Hierarchical decomposition of vehicle mass
+    'Weight Fraction'
+        Component weight divided by total weight
+    'Zero Fuel Weight'
+        Aircraft weight excluding fuel
+    'Maximum Takeoff Weight'
+        Maximum allowable total weight
+    
+    See Also
+    --------
+    RCAIDE.Library.Analysis.Weights : Weight analysis tools
+    """
+
+    breakdown =  vehicle.mass_properties.weight_breakdown     
+    
+    level_1 = []
+    level_2 = []
+    level_3 = []
+    values  = []
+      
+    for tag ,  item in  breakdown.items():
+        if tag == 'zero_fuel_weight' or   tag == 'max_takeoff':
+            pass
+        else:
+            if type(item)  == RCAIDE.Framework.Core.Data: 
+                for  sub_tag  , sub_item in item.items():
+                    if type(sub_item) == RCAIDE.Framework.Core.Data: 
+                        for sub_sub_tag ,  sub_sub_item in sub_item.items():
+                            if sub_sub_tag != 'total':
+                                level_1.append(tag.replace("_", " "))
+                                level_2.append(sub_tag.replace("_", " "))
+                                level_3.append(sub_sub_tag.replace("_", " "))
+                                values.append(sub_sub_item )
+                    elif sub_tag != 'total':
+                        level_1.append(tag.replace("_", " "))
+                        level_2.append(sub_tag.replace("_", " "))
+                        level_3.append(np.nan)
+                        values.append(sub_item) 
+            elif tag == 'fuel':
+                level_1.append(tag.replace("_", " "))
+                level_2.append(np.nan)
+                level_3.append(np.nan)
+                values.append(sub_item) 
+                  
+    df = pd.DataFrame(
+        dict(level_1=level_1, level_2=level_2, level_3=level_3, values=values)
+    ) 
+    fig = px.sunburst(df,
+                      path=['level_1', 'level_2', 'level_3'], 
+                      values='values',  
+                      color_discrete_sequence=px.colors.qualitative.G10)
+    
+    # Add a dummy inner layer for the hole
+    fig.update_traces(
+        textfont=dict(size=20), 
+        insidetextorientation='horizontal', 
+        textinfo='label+percent entry', 
+        marker=dict(colors=['rgba(0,0,0,0)'] + px.colors.qualitative.G10)
+    )
+    fig.update_layout( 
+    uniformtext=dict(minsize=12, mode='hide'),
+    )
+ 
+    if save_figure:
+        fig.write_image(save_filename + file_type)
+    
+    if show_figure:
+        fig.write_html( save_filename + '.html', auto_open=True)        
+    return  fig