RCAIDE-GUI 1.0.0__py3-none-any.whl

tabs/solve/plots/energy/plot_battery_module_C_rates.py

@@ -0,0 +1,139 @@
+# RCAIDE_GUI/tabs/solve/plots/energy/plot_battery_module_C_rates.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 Battery Module C Rates
+# ------------------------------------------------------------------------------
+def plot_battery_module_C_rates(results,
+                        save_figure   = False,
+                        show_legend   = True,
+                        save_filename = "Battery_Module_C_Rates",
+                        file_type     =".png",
+                        width         = 8,
+                        height        = 6):
+    """
+    Creates a two-panel plot showing instantaneous and nominal C-rates of battery modules during operation.
+
+    Parameters
+    ----------
+    results : Results
+        RCAIDE results structure containing segment data and battery conditions
+        
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    show_legend : bool, optional
+        Flag for displaying plot legend (default: True)
+        
+    save_filename : str, optional
+        Base name of file for saved figure (default: "Battery_Module_C_Rates")
+        
+    file_type : str, optional
+        File extension for saved figure (default: ".png")
+        
+    width : float, optional
+        Figure width in inches (default: 8)
+        
+    height : float, optional
+        Figure height in inches (default: 6)
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+
+    Notes
+    -----
+    The function creates a 1x2 subplot showing:
+        1. Instantaneous C-rate vs time
+        2. Nominal C-rate vs time
+    
+    Different segments are plotted with different colors using the inferno colormap.
+    For multiple battery modules, only non-identical modules are plotted.
+    
+    **Major Assumptions**
+    
+    * For identical battery modules, only the first module's data is plotted
+    * Time is converted from seconds to minutes for plotting
+    * Battery energy is converted to Watt-hours for calculations
+    
+    **Definitions**
+    
+    'C-rate'
+        A measure of the rate at which a battery is discharged relative to its capacity
+    'Instantaneous C-rate'
+        C-rate calculated using the current battery capacity
+    'Nominal C-rate'
+        C-rate calculated using the maximum battery capacity
+    """ 
+     
+    # 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)
+    # get line colors for plots 
+    line_colors   = cm.inferno(np.linspace(0,0.9,len(results.segments)))      
+    axis_1 = plt.subplot(1,2,1)
+    axis_2 = plt.subplot(1,2,2)  
+     
+    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    
+                        battery_conditions    = results.segments[i].conditions.energy.busses[bus.tag].battery_modules[battery.tag]
+                        module_energy         = battery_conditions.energy[:,0]
+                        module_volts          = battery_conditions.voltage_under_load[:,0] 
+                        module_current        = battery_conditions.current[:,0]  
+                        module_battery_amp_hr = (module_energy/ Units.Wh )/module_volts
+                        module_C_instant      = module_current/module_battery_amp_hr
+                        module_C_nominal      = module_current/np.max(module_battery_amp_hr)   
+    
+                        if i == 0 and i ==0:              
+                            axis_1.plot(time, module_C_instant, color = line_colors[i], marker = ps.markers[0], linewidth = ps.line_width, label = battery.tag)
+                        else: 
+                            axis_1.plot(time, module_C_instant, color = line_colors[i], marker = ps.markers[0], linewidth = ps.line_width)                                
+                        axis_1.set_ylabel(r'Inst. C-Rate (C)')
+                        axis_1.set_xlabel('Time (mins)')
+                        set_axes(axis_1)     
+                         
+                        axis_2.plot(time, module_C_nominal, color = line_colors[i], marker = ps.markers[0], linewidth = ps.line_width)
+                        axis_2.set_ylabel(r'Nom. C-Rate (C)')
+                        axis_2.set_xlabel('Time (mins)')
+                        set_axes(axis_2)    
+    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) 
+    
+    # set title of plot 
+    title_text   = 'Battery Cell Conditions'       
+    fig.suptitle(title_text) 
+    
+    if save_figure:
+        plt.savefig(save_filename + battery.tag + file_type)    
+    return fig
+
+
+    return  
+ 
+                 

tabs/solve/plots/energy/plot_battery_module_conditions.py

@@ -0,0 +1,157 @@
+# RCAIDE_GUI/tabs/solve/plots/energy/plot_battery_module_conditions.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 Battery Module Conditions
+# ------------------------------------------------------------------------------
+def plot_battery_module_conditions(results,
+                                  save_figure = False,
+                                  show_legend = True,
+                                  save_filename = "Battery_Module_Conditions_",
+                                  file_type = ".png",
+                                  width = 11, height = 7):
+    """
+    Creates a six-panel plot showing various battery module-level conditions throughout flight.
+
+    Parameters
+    ----------
+    results : Results
+        RCAIDE results structure containing segment data and battery module conditions
+        
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    show_legend : bool, optional
+        Flag for displaying plot legend (default: True)
+        
+    save_filename : str, optional
+        Base name of file for saved figure (default: "Battery_Module_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
+
+    Notes
+    -----
+    The function creates a 3x2 subplot containing:
+        1. State of Charge (SOC) vs time
+        2. Module energy vs time
+        3. Module current vs time
+        4. Module power vs time
+        5. Module voltage vs time
+        6. Module temperature vs time
+    
+    Each segment is plotted with a different color from the inferno colormap.
+    Different battery modules are distinguished by different markers.
+    
+    **Major Assumptions**
+    
+    * For identical battery modules, only the first module's data is plotted
+    * Time is converted from seconds to minutes for plotting
+    * Energy is converted to Watt-hours for display
+    
+    **Definitions**
+    
+    'SOC'
+        State of Charge - the level of charge of the battery module relative to its capacity
+    'Module Power'
+        Total electrical power of the battery module
+    'Module Energy'
+        Cumulative energy stored/discharged by the battery module
+    """  
+    
+    # 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)
+    # get line colors for plots 
+    line_colors   = cm.inferno(np.linspace(0,0.9,len(results.segments)))      
+    axis_1 = plt.subplot(3,2,1)
+    axis_2 = plt.subplot(3,2,2) 
+    axis_3 = plt.subplot(3,2,3) 
+    axis_4 = plt.subplot(3,2,4)
+    axis_5 = plt.subplot(3,2,5) 
+    axis_6 = plt.subplot(3,2,6)
+     
+    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    
+                        battery_conditions  = results.segments[i].conditions.energy.busses[bus.tag].battery_modules[battery.tag]
+                        module_power          = battery_conditions.power[:,0]
+                        module_energy         = battery_conditions.energy[:,0]
+                        module_volts          = battery_conditions.voltage_under_load[:,0] 
+                        module_current        = battery_conditions.current[:,0]
+                        module_SOC            = battery_conditions.cell.state_of_charge[:,0]   
+                        module_temperature    = battery_conditions.temperature[:,0]   
+                    
+                        if b_i == 0 and i ==0:                             
+                            axis_1.plot(time, module_SOC, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width, label = battery.tag)
+                        else:
+                            axis_1.plot(time, module_SOC, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_1.set_ylabel(r'SOC')
+                        axis_1.set_ylim([0,1.1])
+                        set_axes(axis_1)     
+                    
+                        axis_2.plot(time, module_energy/Units.Wh, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_2.set_ylabel(r'Energy (W-hr)')
+                        set_axes(axis_2) 
+                    
+                        axis_3.plot(time, module_current, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_3.set_ylabel(r'Current (A)')
+                        set_axes(axis_3)  
+                    
+                        axis_4.plot(time, module_power, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_4.set_ylabel(r'Power (W)')
+                        set_axes(axis_4)     
+                    
+                        axis_5.plot(time, module_volts, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width) 
+                        axis_5.set_ylabel(r'Voltage (V)')
+                        set_axes(axis_5) 
+                    
+                        axis_6.plot(time, module_temperature, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                        axis_6.set_ylabel(r'Temperature, $\degree$C')
+                        set_axes(axis_6)  
+                  
+    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) 
+    
+    # set title of plot 
+    title_text   = 'Battery Module Conditions'       
+    fig.suptitle(title_text) 
+    
+    if save_figure:
+        plt.savefig(save_filename + battery.tag + file_type)    
+    return fig 

tabs/solve/plots/energy/plot_battery_pack_conditions.py

@@ -0,0 +1,164 @@
+# RCAIDE_GUI/tabs/solve/plots/energy/plot_battery_pack_conditions.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 Battery Pack Conditions
+# ------------------------------------------------------------------------------
+def plot_battery_pack_conditions(results,
+                                  save_figure = False,
+                                  show_legend = True,
+                                  save_filename = "Battery_Pack_Conditions_",
+                                  file_type = ".png",
+                                  width = 11, height = 7):
+    """
+    Creates a six-panel plot showing various battery pack-level conditions throughout flight.
+
+    Parameters
+    ----------
+    results : Results
+        RCAIDE results structure containing segment data and battery pack conditions
+        
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    show_legend : bool, optional
+        Flag for displaying plot legend (default: True)
+        
+    save_filename : str, optional
+        Base name of file for saved figure (default: "Battery_Pack_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
+
+    Notes
+    -----
+    The function creates a 3x2 subplot containing:
+        1. State of Charge (SOC) vs time
+        2. Pack energy vs time
+        3. Pack current vs time
+        4. Pack power vs time
+        5. Pack voltage vs time
+        6. Pack temperature vs time
+    
+    Each segment is plotted with a different color from the inferno colormap.
+    Different battery modules are distinguished by different markers.
+    
+    **Major Assumptions**
+     
+    * Time is converted from seconds to minutes for plotting
+    * Energy is converted to Watt-hours for display
+    
+    **Definitions**
+    
+    'SOC'
+        State of Charge - the level of charge of the battery pack relative to its capacity
+    'Module Power'
+        Total electrical power of the battery pack
+    'Module Energy'
+        Cumulative energy stored/discharged by the battery pack
+    """  
+    
+    # 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)
+    # get line colors for plots 
+    line_colors   = cm.inferno(np.linspace(0,0.9,len(results.segments)))      
+    axis_1 = plt.subplot(3,2,1)
+    axis_2 = plt.subplot(3,2,2) 
+    axis_3 = plt.subplot(3,2,3) 
+    axis_4 = plt.subplot(3,2,4)
+    axis_5 = plt.subplot(3,2,5) 
+    axis_6 = plt.subplot(3,2,6)
+     
+    for network in results.segments[0].analyses.vehicle.networks: 
+        busses  = network.busses 
+        for  b_i , bus in  enumerate(busses): 
+            for i in range(len(results.segments)): 
+                no_modules         = len(bus.battery_modules) 
+                bus_config         = bus.battery_module_electric_configuration 
+                battery_module_tag = list(bus.battery_modules.keys())[0]
+                
+                time                = results.segments[i].conditions.frames.inertial.time[:,0] / Units.min    
+                battery_conditions  = results.segments[i].conditions.energy.busses[bus.tag].battery_modules[battery_module_tag]
+             
+                if bus_config == 'Series':
+                    pack_current        = battery_conditions.current[:,0] 
+                    pack_volts          = battery_conditions.voltage_under_load[:,0]   * no_modules                          
+                elif bus_config  == 'Parallel': 
+                    pack_current        = battery_conditions.current[:,0] * no_modules
+                    pack_volts          = battery_conditions.voltage_under_load[:,0]   
+                    
+                pack_power          = battery_conditions.power[:,0] * no_modules
+                pack_energy         = battery_conditions.energy[:,0] * no_modules
+                pack_SOC            = battery_conditions.cell.state_of_charge[:,0]   
+                pack_temperature    = battery_conditions.temperature[:,0]   
+            
+                if b_i == 0 and i ==0:                             
+                    axis_1.plot(time, pack_SOC, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width, label = bus.tag)
+                else:
+                    axis_1.plot(time, pack_SOC, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                axis_1.set_ylabel(r'SOC')
+                axis_1.set_ylim([0,1.1])
+                set_axes(axis_1)     
+            
+                axis_2.plot(time, pack_energy/1000/Units.Wh, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                axis_2.set_ylabel(r'Energy (kW-hr)')
+                set_axes(axis_2) 
+            
+                axis_3.plot(time, pack_current/1000, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                axis_3.set_ylabel(r'Current (kA)')
+                set_axes(axis_3)  
+            
+                axis_4.plot(time, pack_power/1000, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                axis_4.set_ylabel(r'Power (kW)')
+                set_axes(axis_4)     
+            
+                axis_5.plot(time, pack_volts/1000, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width) 
+                axis_5.set_ylabel(r'Voltage (kV)')
+                set_axes(axis_5) 
+            
+                axis_6.plot(time, pack_temperature, color = line_colors[i], marker = ps.markers[b_i], linewidth = ps.line_width)
+                axis_6.set_ylabel(r'Temperature, $\degree$C')
+                set_axes(axis_6)  
+                  
+    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) 
+    
+    # set title of plot 
+    title_text   = 'Battery Pack Conditions'       
+    fig.suptitle(title_text) 
+    
+    if save_figure:
+        plt.savefig(save_filename + file_type)    
+    return fig 

tabs/solve/plots/energy/plot_battery_ragone_diagram.py

@@ -0,0 +1,97 @@
+# RCAIDE_GUI/tabs/solve/plots/energy/plot_battery_ragone_diagram.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 Battery Ragone Diagram
+# ------------------------------------------------------------------------------
+def plot_battery_ragone_diagram(battery,
+                          save_figure   = False, 
+                          save_filename = "Ragone_Plot",
+                          file_type     =  ".png",
+                          width = 11, height = 7):
+    """
+    Creates a Ragone plot showing the relationship between specific power and specific energy of a battery.
+
+    Parameters
+    ----------
+    battery : Battery
+        RCAIDE battery object containing Ragone characteristics
+        
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    save_filename : str, optional
+        Name of file for saved figure (default: "Ragone_Plot")
+        
+    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
+        Figure handle containing the generated Ragone plot
+
+    Notes
+    -----
+    The Ragone plot is a performance map showing the tradeoff between specific power 
+    and specific energy in energy storage devices. The plot uses logarithmic scales 
+    to display the wide range of values.
+    
+    **Major Assumptions**
+    
+    * Battery characteristics follow the Ragone relationship:
+        P = const_1 * 10^(E * const_2)
+    * Specific energy range is defined by upper and lower bounds
+    * Values are converted to standard units (kW/kg and Wh/kg)
+
+    **Definitions**
+    
+    'Specific Power'
+        Power output per unit mass (kW/kg)
+    'Specific Energy'
+        Energy storage capacity per unit mass (Wh/kg)
+    'Ragone Plot'
+        Performance visualization showing the tradeoff between power and energy density
+    """
+ 
+    # 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_1 = plt.subplot(1,1,1)
+    esp_plot = np.linspace(battery.cell.ragone.lower_bound, battery.cell.ragone.upper_bound,50)
+    psp_plot = battery.cell.ragone.const_1*10**(esp_plot*battery.cell.ragone.const_2)
+    axis_1.plot(esp_plot/(Units.Wh/Units.kg),psp_plot/(Units.kW/Units.kg), color = 'black', marker = ps.markers[0], linewidth = ps.line_width, label= battery.tag) 
+    axis_1.set_ylabel('Specific Power (kW/kg)')
+    axis_1.set_xlabel('Specific Energy (W-h/kg)')
+    set_axes(axis_1)       
+     
+    # set title of plot 
+    title_text    = 'Battery Ragone Plot'      
+    fig.suptitle(title_text)
+    
+    if save_figure:
+        plt.savefig(save_filename + file_type)   
+    return  fig 

tabs/solve/plots/energy/plot_battery_temperature.py

@@ -0,0 +1,136 @@
+# RCAIDE_GUI/tabs/solve/plots/energy/plot_battery_temperature.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 Battery Temperature
+# ------------------------------------------------------------------------------
+def plot_battery_temperature(results,
+                                  save_figure = False,
+                                  show_legend = True,
+                                  save_filename = "Battery_Temperature",
+                                  file_type = ".png",
+                                  width = 11, height = 7):
+    """
+    Creates a three-panel plot showing battery thermal conditions and related parameters throughout flight.
+
+    Parameters
+    ----------
+    results : Results
+        RCAIDE results structure containing segment data and battery thermal conditions
+        
+    save_figure : bool, optional
+        Flag for saving the figure (default: False)
+        
+    show_legend : bool, optional
+        Flag for displaying plot legend (default: True)
+        
+    save_filename : str, optional
+        Name of file for saved figure (default: "Battery_Temperature")
+        
+    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
+    -----
+    The function creates a 2x2 subplot containing:
+        1. Cell temperature vs time
+        2. Charge throughput vs time
+        3. Heat generation rate vs time
+    
+    Each segment is plotted with a different color from the inferno colormap.
+    Different battery modules are distinguished by different markers.
+    
+    **Major Assumptions**
+    
+    * For identical battery modules, only the first module's data is plotted
+    * Time is converted from seconds to minutes for plotting
+    * Heat generation rate is converted to kilowatts for display
+    
+    **Definitions**
+    
+    'Charge Throughput'
+        Cumulative amount of charge that has passed through the battery (Ah)
+    'Heat Generation Rate'
+        Rate of thermal energy production in the battery (kW)
+    """ 
+    
+    # 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)  
+    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_i, bus in enumerate(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)): 
+                        bus_results         = results.segments[i].conditions.energy.busses[bus.tag]
+                        time                = results.segments[i].conditions.frames.inertial.time[:,0] / Units.min                      
+                        battery_conditions  = results.segments[i].conditions.energy.busses[bus.tag].battery_modules[battery.tag]
+                        cell_temp           = battery_conditions.cell.temperature[:,0]
+                        cell_charge         = battery_conditions.cell.charge_throughput[:,0]
+                        pack_Q              = bus_results.heat_energy_generated[:,0]
+                        
+                        if b_i == 0 and i == 0:
+                            axis_1.plot(time,cell_temp, color = line_colors[i], marker = ps.markers[bus_i], linewidth = ps.line_width, label = battery.tag)
+                        else:
+                            axis_1.plot(time,cell_temp, color = line_colors[i], marker = ps.markers[bus_i], linewidth = ps.line_width)
+                        axis_1.set_ylabel(r'Temperature (K)') 
+                        set_axes(axis_1)        
+                        
+                        axis_2.plot(time, cell_charge, color = line_colors[i], marker = ps.markers[bus_i], linewidth = ps.line_width)
+                        axis_2.set_xlabel('Time (mins)')
+                        axis_2.set_ylabel(r'Charge Throughput (Ah)')
+                        set_axes(axis_2)   
+                        
+                        axis_3.plot(time, pack_Q/1000, color = line_colors[i], marker = ps.markers[bus_i], linewidth = ps.line_width)
+                        axis_3.set_xlabel('Time (mins)')
+                        axis_3.set_ylabel(r'$\dot{Q}_{heat}$ (kW)')
+                        set_axes(axis_3) 
+    
+    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)
+    
+    # set title of plot 
+    title_text    = 'Battery Temperature'   
+    fig.suptitle(title_text)
+    
+    if save_figure:
+        plt.savefig(save_filename  + file_type)   
+    return fig