RCAIDE-GUI 1.0.0__py3-none-any.whl

tabs/solve/plots/aeroacoustics/plot_3D_noise_contour.py

@@ -0,0 +1,219 @@
+# RCAIDE_GUI/tabs/solve/plots/aeroacoustics/plot_3D_noise_contour.py
+
+# RCAIDE imports
+from RCAIDE.Framework.Core import Units
+from RCAIDE.Library.Plots  import *
+
+# Python imports
+import numpy as np
+import plotly.graph_objects as go
+
+# ------------------------------------------------------------------------------
+# Plot 3D Noise Contour
+# ------------------------------------------------------------------------------
+def plot_3D_noise_contour(noise_data,
+                       noise_level = None,
+                       min_noise_level = 35,  
+                       max_noise_level = 90, 
+                       noise_scale_label = None,
+                       save_figure = False,
+                       show_figure = True,
+                       save_filename = "Noise_Contour",
+                       use_lat_long_coordinates = True, 
+                       show_trajectory = False,
+                       show_microphones = False,
+                       colormap = 'jet',
+                       file_type = ".png",
+                       background_color = 'rgb(17,54,71)',
+                       grid_color = 'gray',
+                       width = 1400, 
+                       height = 800):
+    """
+    Creates an interactive 3D visualization of noise contours with optional aircraft trajectory.
+
+    Parameters
+    ----------
+    noise_data : NoiseData
+        RCAIDE noise data structure containing:
+            - microphone_locations[:,:,0:3]
+                3D array of microphone positions in (nmi, nmi, ft)
+            - aircraft_position[:,0:3]
+                Aircraft trajectory points in (nmi, nmi, ft)
+            
+    noise_level : ndarray
+        2D array of noise levels at measurement points
+        
+    min_noise_level : float, optional
+        Minimum noise level for contour scale (default: 35 dB)
+        
+    max_noise_level : float, optional
+        Maximum noise level for contour scale (default: 90 dB)
+        
+    noise_scale_label : str, optional
+        Label for noise metric (e.g., "dBA", "EPNL", etc.)
+        
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    show_figure : bool, optional
+        Flag to display the figure (default: True)
+        
+    save_filename : str, optional
+        Name of file for saved figure (default: "Noise_Contour")
+        
+    use_lat_long_coordinates : bool, optional
+        Flag to use geographic coordinates (default: True)
+        
+    show_trajectory : bool, optional
+        Flag to display aircraft trajectory (default: False)
+        
+    show_microphones : bool, optional
+        Flag to display microphone locations (default: False)
+        
+    colormap : str, optional
+        Colormap specification for noise contours (default: 'jet')
+        
+    file_type : str, optional
+        File extension for saved figure (default: ".png")
+        
+    background_color : str, optional
+        Color specification for plot background (default: 'rgb(17,54,71)')
+        
+    grid_color : str, optional
+        Color specification for grid lines (default: 'gray')
+        
+    width : int, optional
+        Figure width in pixels (default: 1400)
+        
+    height : int, optional
+        Figure height in pixels (default: 800)
+
+    Returns
+    -------
+    fig_3d : plotly.graph_objects.Figure
+        Handle to the generated interactive 3D figure
+
+    Notes
+    -----
+    Creates visualization showing:
+        * 3D noise contour surface
+        * Optional aircraft trajectory
+        * Optional microphone locations
+        * Interactive viewing controls
+        * Customizable appearance
+    
+    **Major Assumptions**
+        * Noise levels are in decibels
+        * Coordinates are in nautical miles and feet
+        * Measurement grid is regularly spaced
+        * Z-axis represents elevation
+    
+    **Definitions**
+    
+    'Noise Contour'
+        Surface of constant noise level
+    'Aircraft Trajectory'
+        Time history of aircraft position
+    'Microphone Location'
+        Measurement point coordinates
+    
+    See Also
+    --------
+    RCAIDE.Library.Plots.Noise.plot_2D_noise_contour : 2D visualization of noise field
+    RCAIDE.Library.Plots.Noise.contour_surface_slice : Surface generation utility
+    """   
+    Aircraft_pos    = noise_data.aircraft_position      
+    X               = noise_data.microphone_locations[:,:,0]/Units.nmi  
+    Y               = noise_data.microphone_locations[:,:,1]/Units.nmi  
+    Z               = noise_data.microphone_locations[:,:,2]/Units.feet  
+    plot_data       = []   
+  
+    # ---------------------------------------------------------------------------
+    # TRHEE DIMENSIONAL NOISE CONTOUR
+    # --------------------------------------------------------------------------- 
+    # TERRAIN CONTOUR 
+    ground_contour   = contour_surface_slice(Y,X,Z,noise_level,color_scale=colormap)
+    plot_data.append(ground_contour)
+
+    # GROUND MICROPHONES
+    if show_microphones:
+        microphones = go.Scatter3d(x        = Y.flatten(),
+                                   y        = X.flatten(),
+                                   z        = Z.flatten(),
+                                   mode     = 'markers',
+                                   marker   = dict(size=6,color='white',opacity=0.8),
+                                   line     = dict(color='white',width=2))
+        plot_data.append(microphones)
+
+    # AIRCRAFT TRAJECTORY
+    if show_trajectory:
+        aircraft_trajectory = go.Scatter3d(x   = Aircraft_pos[:,1]/Units.nmi,
+                                           y   = Aircraft_pos[:,0]/Units.nmi,
+                                           z   = Aircraft_pos[:,2]/Units.feet,
+                                           mode= 'markers',
+                                           marker=dict(size=6,
+                                                       color='black',
+                                                       opacity=0.8),
+                                    line=dict(color='black',width=2))
+        plot_data.append(aircraft_trajectory)
+
+    # Define Colorbar Bounds
+    min_alt     = np.minimum(np.min(Z),0) 
+    max_alt     = np.maximum(np.max(Z), np.max(Aircraft_pos[:,2]/Units.feet)) 
+  
+    fig_3d = go.Figure(data=plot_data) 
+
+    if show_microphones or show_trajectory:
+        pass
+    else: 
+        fig_3d.update_traces(colorbar_orientation     = 'v',
+                             colorbar_thickness       = 50,
+                             colorbar_nticks          = 10,
+                             colorbar_title_text      = noise_scale_label,
+                             colorbar_tickfont_size   = 16,
+                             colorbar_title_side      = "right",
+                             colorbar_ypad            = 50,
+                             colorbar_len             = 0.75)
+        
+                         
+    fig_3d.update_layout(
+             title_text                             = save_filename, 
+             title_x                                = 0.5,
+             width                                  = width,
+             height                                 = height,
+             font_size                              = 12,
+             scene_aspectmode                       = "manual",
+             scene_aspectratio                      = dict(x=1, y=1, z=0.5),      
+             scene_zaxis_range                      = [min_alt,max_alt*3],
+             scene                                  = dict(xaxis_title='Latitude [nmi]',
+                                                           yaxis_title='Longitude [nmi]',
+                                                           zaxis_title='Elevation [ft]',
+                                                           xaxis = dict(
+                                                                backgroundcolor=background_color,
+                                                                gridcolor="white",
+                                                                showbackground=True,
+                                                                zerolinecolor=grid_color,),
+                                                           yaxis = dict(
+                                                               backgroundcolor=background_color,
+                                                               gridcolor=grid_color,
+                                                               showbackground=True,
+                                                               zerolinecolor="white"),
+                                                           zaxis = dict(
+                                                               backgroundcolor=background_color,
+                                                               gridcolor=grid_color,
+                                                               showbackground=True,
+                                                               zerolinecolor="white",),),
+             scene_camera=dict(up    = dict(x=0, y=0, z=1),
+                               center= dict(x=-0.05, y=0, z=-0.20),
+                               eye   = dict(x=-1.0, y=-1.0, z=.4))   
+    ) 
+    if show_figure:
+        fig_3d.show() 
+    if save_figure:
+        fig_3d.write_image(save_filename, file_type)
+
+    return fig_3d       
+
+def colorax(vmin, vmax):
+    return dict(cmin=vmin, cmax=vmax)
+ 

tabs/solve/plots/aeroacoustics/plot_noise_certification_contour.py

@@ -0,0 +1,115 @@
+# RCAIDE_GUI/tabs/solve/plots/aeroacoustics/plot_noise_certification_contour.py
+
+# RCAIDE imports
+import matplotlib.colors
+import matplotlib.colors as colors
+from RCAIDE.Library.Plots import *
+
+# Python imports
+import numpy as np
+from matplotlib import pyplot as plt
+
+# ------------------------------------------------------------------------------
+# Plot Noise Certification Contour
+# ------------------------------------------------------------------------------
+def plot_noise_certification_contour( noise_data,
+                                    noise_level       = None, 
+                                    min_noise_level   = 45,  
+                                    max_noise_level   = 105, 
+                                    noise_scale_label = "Max. SPL [dbA]",
+                                    save_figure       = False,
+                                    show_figure       = True,
+                                    save_filename     = "Certification_Noise", 
+                                    colormap          = 'jet',
+                                    file_type         = ".png",
+                                    width             = 12, 
+                                    height            = 6):
+     
+      
+    fig = plt.figure(save_filename)
+    fig.set_size_inches(width,height) 
+    
+    noise_levels   = np.linspace(min_noise_level,max_noise_level,7)  
+    noise_cmap     = plt.get_cmap('turbo')
+    noise_new_cmap = truncate_colormap(noise_cmap,0.0, 1.0) 
+
+    noise_level = noise_data.certification_SPL_dBA_max           
+    X           = noise_data.certification_microphone_locations[:,:,0]
+    Y           = noise_data.certification_microphone_locations[:,:,1] 
+    
+    ap_noise_level = noise_data.approach_SPL_dBA_max           
+    ap_X           = noise_data.approach_microphone_locations[:,:,0]
+    ap_Y           = noise_data.approach_microphone_locations[:,:,1]
+    ap_POS         = noise_data.approach_trajectory
+
+    to_noise_level = noise_data.takeoff_SPL_dBA_max           
+    to_X           = noise_data.takeoff_microphone_locations[:,:,0]
+    to_Y           = noise_data.takeoff_microphone_locations[:,:,1]
+    to_POS         = noise_data.takeoff_trajectory
+    
+    axis_0   = fig.add_subplot(2,2,1) 
+    axis_0.set_xlabel('x [m]')
+    axis_0.set_ylabel('altitude [m]')   
+    axis_1   = fig.add_subplot(2,2,3) 
+    axis_1.set_xlabel('x [m]')
+    axis_1.set_ylabel('y [m]')   
+    axis_2   = fig.add_subplot(2,2,2) 
+    axis_2.set_xlabel('x [m]')
+    axis_2.set_ylabel('y [m]')   
+    axis_3   = fig.add_subplot(2,2,4) 
+    axis_3.set_xlabel('x [m]')
+    axis_3.set_ylabel('y [m]')
+    
+    # plot aircraft position
+    axis_0.plot(ap_POS[:,0],-ap_POS[:,2], color = 'black', linestyle = '-' , marker = 'o', linewidth = 2, label= "Approach")
+    axis_0.plot(to_POS[:,0],-to_POS[:,2], color = 'blue', linestyle = '-' , marker = 's', linewidth = 2, label= "Takeoff")
+    axis_0.legend(loc='upper center') 
+
+    # plot aircraft noise levels   
+    CS_11    = axis_1.contourf(X,Y,noise_level ,noise_levels,cmap = noise_new_cmap,extend='both')  
+    CS_12    = axis_1.contourf(X,-Y,noise_level ,noise_levels,cmap = noise_new_cmap,extend='both')
+    CS_21    = axis_2.contourf(ap_X,ap_Y,ap_noise_level ,noise_levels,cmap = noise_new_cmap,extend='both')  
+    CS_22    = axis_2.contourf(ap_X,-ap_Y,ap_noise_level ,noise_levels,cmap = noise_new_cmap,extend='both')
+    CS_31    = axis_3.contourf(to_X,to_Y,to_noise_level ,noise_levels,cmap = noise_new_cmap,extend='both')  
+    CS_32    = axis_3.contourf(to_X,-to_Y,to_noise_level ,noise_levels,cmap = noise_new_cmap,extend='both')
+     
+    cbar  = fig.colorbar(CS_11, ax=axis_1)        
+    cbar.ax.set_ylabel(noise_scale_label, rotation =  90)
+
+    cbar  = fig.colorbar(CS_11, ax=axis_2)        
+    cbar.ax.set_ylabel(noise_scale_label, rotation =  90)
+
+    cbar  = fig.colorbar(CS_11, ax=axis_3)        
+    cbar.ax.set_ylabel(noise_scale_label, rotation =  90)     
+
+    run_way_x_pts = np.linspace(0, 3000, 20)
+    run_way_y_pts = run_way_x_pts * 0
+
+    axis_1.plot(run_way_x_pts,run_way_y_pts, color = 'grey', linestyle = '-' , linewidth = 5 , alpha=0.5)
+    axis_2.plot(run_way_x_pts,run_way_y_pts, color = 'grey', linestyle = '-' , linewidth = 5 , alpha=0.5)
+    axis_3.plot(run_way_x_pts,run_way_y_pts, color = 'grey', linestyle = '-' , linewidth = 5 , alpha=0.5)
+    
+    set_axes(axis_1)
+    set_axes(axis_2)
+    set_axes(axis_3)
+
+    axis_0.set_title('Flight Trajectory')        
+    axis_1.set_title('Approach and Takeoff Noise')
+    axis_2.set_title('Approach Noise')
+    axis_3.set_title('Takeoff Noise')
+    
+    fig.tight_layout()  
+    if save_figure: 
+        figure_title  = save_filename
+        plt.savefig(figure_title + file_type )   
+    
+
+# ------------------------------------------------------------------ 
+# Truncate colormaps
+# ------------------------------------------------------------------  
+def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
+    new_cmap = colors.LinearSegmentedColormap.from_list(
+        'trunc({n},{a:.2f},{b:.2f})'.format(n=cmap.name, a=minval, b=maxval),
+        cmap(np.linspace(minval, maxval, n)))
+    return new_cmap
+        

tabs/solve/plots/aeroacoustics/plot_noise_level.py

@@ -0,0 +1,118 @@
+# RCAIDE_GUI/tabs/solve/plots/aeroacoustics/plot_noise_level.py
+
+# RCAIDE imports
+from RCAIDE.Framework.Core import Units
+from RCAIDE.Library.Plots.Common import set_axes, plot_style
+
+# Python imports
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+import numpy as np
+
+# ------------------------------------------------------------------------------
+# Plot Noise Level
+# ------------------------------------------------------------------------------
+def plot_noise_level(noise_data,
+                     noise_level = False,
+                     save_figure = False,
+                     save_filename = "Sideline_Noise_Levels",
+                     file_type = ".png",
+                     width = 11, height = 7):
+    """
+    Creates a visualization of A-weighted Sound Pressure Levels at various sideline distances.
+
+    Parameters
+    ----------
+    noise_data : NoiseData
+        RCAIDE noise data structure containing:
+            - microphone_y_resolution : int
+                Number of sideline measurement positions
+            - microphone_locations : ndarray
+                3D array of microphone positions where:
+                    - [:,:,0] : x-positions (longitudinal)
+                    - [:,:,1] : y-positions (sideline)
+                    - [:,:,2] : z-positions (vertical)
+            
+    noise_level : ndarray, optional
+        2D array of noise levels at measurement points (default: False)
+        
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    save_filename : str, optional
+        Name of file for saved figure (default: "Sideline_Noise_Levels")
+        
+    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 showing noise levels vs range
+
+    Notes
+    -----
+    Creates visualization showing:
+        * Noise level variation with distance
+        * Multiple sideline measurement positions
+        * Color-coded sideline distances
+        * Customizable appearance
+    
+    **Major Assumptions**
+        * Noise levels are A-weighted SPL in dBA
+        * Microphones are in a regular grid
+        * Range is in nautical miles
+        * Sideline distances are in meters
+    
+    **Definitions**
+    
+    'Sound Pressure Level'
+        A-weighted acoustic pressure level in dBA
+    'Sideline Distance'
+        Perpendicular distance from flight path
+    'Range'
+        Distance along flight path
+    
+    See Also
+    --------
+    RCAIDE.Library.Plots.Noise.plot_2D_noise_contour : 2D contour visualization
+    RCAIDE.Library.Plots.Noise.plot_3D_noise_contour : 3D noise field visualization
+    """      
+    N_gm_y       = noise_data.microphone_y_resolution 
+    gm           = noise_data.microphone_locations    
+    gm_x         = gm[:,:,0]
+    gm_y         = gm[:,:,1]    
+    
+
+    # 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)
+    axes        = fig.add_subplot(1,1,1) 
+    
+    # get line colors for plots 
+    line_colors   = cm.inferno(np.linspace(0,0.9,N_gm_y))  
+      
+    for k in range(N_gm_y):    
+        axes.plot(gm_x[:,0]/Units.nmi, noise_level[:,k], marker = 'o', color = line_colors[k], label= r'mic at y = ' + str(round(gm_y[0,k],1)) + r' m' ) 
+    axes.set_ylabel('SPL [dBA]')
+    axes.set_xlabel('Range [nmi]')  
+    set_axes(axes)
+    axes.legend(loc='upper right')         
+    if save_figure:
+        plt.savefig(save_filename + ".png")    
+        
+    return fig

tabs/solve/plots/aerodynamics/__init__.py

@@ -0,0 +1,10 @@
+# RCAIDE_GUI/tabs/solve/plots/aerodynamics/__init__.py
+
+from .plot_aircraft_aerodynamics                import plot_aircraft_aerodynamics
+from .plot_aerodynamic_coefficients             import plot_aerodynamic_coefficients
+from .plot_aerodynamic_forces                   import plot_aerodynamic_forces
+from .plot_drag_components                      import plot_drag_components
+from .plot_lift_distribution                    import plot_lift_distribution
+from .plot_rotor_disc_performance               import plot_rotor_disc_performance
+from .plot_rotor_performance                    import plot_rotor_performance
+from .plot_rotor_conditions                     import plot_rotor_conditions

tabs/solve/plots/aerodynamics/plot_aerodynamic_coefficients.py

@@ -0,0 +1,156 @@
+# RCAIDE_GUI/tabs/solve/plots/aerodynamics/plot_aerodynamic_coefficients.py
+
+# RCAIDE imports
+from RCAIDE.Framework.Core import Units
+from RCAIDE.Library.Plots.Common import set_axes, plot_style
+
+# Python imports
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+import numpy as np
+
+# ------------------------------------------------------------------------------
+# Plot Aerodynamic Coefficients
+# ------------------------------------------------------------------------------
+def plot_aerodynamic_coefficients(results,
+                             save_figure = False,  
+                             show_legend = True,
+                             save_filename = "Aerodynamic_Coefficients",
+                             file_type = ".png",
+                             width = 11, height = 7):
+    """
+    Creates a multi-panel visualization of aerodynamic coefficients throughout flight.
+
+    Parameters
+    ----------
+    results : Results
+        RCAIDE results data structure containing:
+            - segments[i].conditions.aerodynamics.coefficients
+                Coefficient data containing:
+                    - lift.total[:,0,None]
+                        Total lift coefficient
+                    - drag.total[:,0,None]
+                        Total drag coefficient
+            - segments[i].conditions.aerodynamics.angles
+                Angle data containing:
+                    - alpha[:,0]
+                        Angle of attack in radians
+            - segments[i].conditions.frames.inertial.time[:,0]
+                Time history for each segment
+            - segments[i].tag
+                Segment identifier string
+            
+    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: "Aerodynamic_Coefficients")
+        
+    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
+        
+
+    Notes
+    -----
+    Creates visualization showing:
+        - Aerodynamic performance metrics
+        - Flight attitude history
+        - Efficiency characteristics
+        - Time evolution of coefficients
+    
+    **Major Assumptions**
+        * Quasi-steady aerodynamics
+        * Small angle approximations
+        * Incompressible flow
+        * Linear lift curve slope
+        * Negligible sideslip
+    
+    **Definitions**
+    
+    'Lift Coefficient'
+        Non-dimensional lift force
+    'Drag Coefficient'
+        Non-dimensional drag force
+    'Angle of Attack'
+        Angle between airflow and reference line
+    'L/D Ratio'
+        Measure of aerodynamic efficiency
+    
+    See Also
+    --------
+    RCAIDE.Library.Plots.Aerodynamics.plot_aerodynamic_forces : Dimensional force plots
+    RCAIDE.Library.Plots.Aerodynamics.plot_drag_components : Drag breakdown 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(save_filename)
+    fig.set_size_inches(width,height)
+     
+    for i in range(len(results.segments)): 
+        time = results.segments[i].conditions.frames.inertial.time[:,0] / Units.min
+        cl   = results.segments[i].conditions.aerodynamics.coefficients.lift.total[:,0,None]
+        cd   = results.segments[i].conditions.aerodynamics.coefficients.drag.total[:,0,None]
+        aoa  = results.segments[i].conditions.aerodynamics.angles.alpha[:,0] / Units.deg
+        l_d  = cl/cd    
+                       
+        segment_tag  =  results.segments[i].tag
+        segment_name = segment_tag.replace('_', ' ')
+        axis_1 = plt.subplot(2,2,1) 
+        axis_1.plot(time, aoa, color = line_colors[i], marker = ps.markers[0],markersize = ps.marker_size, linewidth = ps.line_width, label = segment_name) 
+        axis_1.set_ylabel(r'AoA (deg)') 
+        axis_1.set_xlabel('Time (mins)')        
+        axis_1.set_ylim([-5,15])
+        set_axes(axis_1)    
+
+        axis_2 = plt.subplot(2,2,2)        
+        axis_2.plot(time, l_d, color = line_colors[i], marker = ps.markers[0],markersize = ps.marker_size, linewidth = ps.line_width) 
+        axis_2.set_ylabel(r'L/D')
+        axis_2.set_xlabel('Time (mins)')
+        set_axes(axis_2) 
+
+        axis_3 = plt.subplot(2,2,3) 
+        axis_3.plot(time, cl, color = line_colors[i], marker = ps.markers[0],markersize = ps.marker_size, linewidth = ps.line_width)
+        axis_3.set_xlabel('Time (mins)')
+        axis_3.set_ylabel(r'$C_L$')
+        set_axes(axis_3) 
+
+        axis_4 = plt.subplot(2,2,4)        
+        axis_4.plot(time, cd, color = line_colors[i], marker = ps.markers[0],markersize = ps.marker_size, linewidth = ps.line_width)
+        axis_4.set_xlabel('Time (mins)')
+        axis_4.set_ylabel(r'$C_D$') 
+        set_axes(axis_4) 
+        
+    if show_legend:
+        leg =  fig.legend(bbox_to_anchor=(0.5, 0.95), loc='upper center', ncol = 4)  
+    
+    # Adjusting the sub-plots for legend
+    fig.tight_layout() 
+    fig.subplots_adjust(top=0.8)  
+    
+    if save_figure:
+        fig.savefig(save_filename   + file_type)  
+    return fig