Thermal performance of the cells
Since only 8P is used we have high per-cell discharge rate which might cause thermal issues
python code block
from sympy import Symbol, solve, expand, pi, lambdify
# Base parameters as symbols
# Geometric parameters
cell_d_mm = Symbol('cell_d_mm') # diameter (mm)
cell_h_mm = Symbol('cell_h_mm') # height (mm)
cell_r_mm = cell_d_mm/2 # radius (mm)
cell_r_m = cell_r_mm / 1000 # radius (m)
cell_d_m = cell_d_mm / 1000 # diameter (m)
cell_h_m = cell_h_mm / 1000 # height (m)
# Pack configuration
n_parallel = Symbol('n_p') # number of cells in parallel
n_series = Symbol('n_s') # number of cells in series
current = Symbol('I') # total current (A)
# Cell electrical properties
cell_ir = Symbol('R_cell') # internal resistance per cell (ohm)
voltage = Symbol('V') # cell voltage (V)
cell_capacity = Symbol('C_cell') # cell capacity (Ah)
# Thermal properties
temperature = Symbol('T') # cell temperature (°C)
ambient_temp = Symbol('T_a') # ambient temperature (°C)
cell_mass = Symbol('m_cell') # cell mass (kg)
spec_heat = Symbol('c_p') # specific heat capacity (J/kg°C)
thermal_cutoff = Symbol('T_max') # thermal cutoff temperature (°C)
thermal_release = Symbol('T_rel') # thermal release temperature (°C)
heat_transfer_coeff = Symbol('h') # heat transfer coefficient W/(m²·K)
# Core relationships
cells_total = n_series * n_parallel
current_per_cell = current / n_parallel
pack_voltage = n_series * voltage
pack_power = current * pack_voltage
# Power and heat calculations
cell_power_loss = current_per_cell**2 * cell_ir
pack_power_loss = cell_power_loss * cells_total
pack_power = current * pack_voltage
efficiency = (pack_power - pack_power_loss) / pack_power * 100
# Temperature calculations
cell_surface_area = 2 * pi * cell_r_m**2 + 2 * pi * cell_r_m * cell_h_m
temp_rise = cell_power_loss / (heat_transfer_coeff * cell_surface_area)
# Time to thermal cutoff calculation
thermal_time = (cell_mass * spec_heat * (thermal_cutoff - ambient_temp)) / cell_power_loss
# Environment specification
env_spec = {
ambient_temp: 40,
heat_transfer_coeff: 10 # W/(m²·K) for natural convection
}
# Battery pack configuration
pack_spec = {
n_parallel: 8,
n_series: 20,
cell_d_mm: 21,
cell_h_mm: 70
}
# Cell specifications (Samsung 50S as default)
cell_spec = {
cell_ir: 0.014, # 14mΩ internal resistance
cell_mass: 0.072, # kg
voltage: 3.6, # V
cell_capacity: 5.0, # Ah
spec_heat: 850, # J/kg°C
thermal_cutoff: 80, # °C
thermal_release: 60 # °C
}
def format_time(x, _=None):
if x < 180:
return f'{x:.0f}s'
elif x < (3600):
minutes = x / 60
return f'{minutes:.1f}min'
else:
hours = x/(3600)
if hours < 24:
return f'{hours:.1f}h'
else:
days = hours/24
return f'{days:.1f}d'
# def calculate_losses(total_current):
# """Calculate losses for a given current"""
# subs_dict = {**cell_spec, **pack_spec, **env_spec, current: total_current}
# heat_per_cell = cell_power_loss.subs(subs_dict)
# total_heat = pack_power_loss.subs(subs_dict)
# eff = efficiency.subs(subs_dict)
# temp_increase = temp_rise.subs(subs_dict)
# time_to_cutoff = thermal_time.subs(subs_dict)
# power = pack_power.subs(subs_dict)
# voltage = pack_voltage.subs(subs_dict)
# print(f"At {int(power)}W")
# print(f"Total current: {total_current}A at {int(voltage)}V")
# print(f"Current per cell: {total_current/pack_spec[n_parallel]:.2f}A")
# print(f"Heat generation per cell: {heat_per_cell:.2f}W")
# print(f"Pack efficiency: {eff:.2f}%")
# print(f"Estimated temp rise above ambient: {temp_increase:.2f}°C")
# print(f"Time to reach {cell_spec[thermal_cutoff]}°C (no cooling): {format_time(float(time_to_cutoff))}")
# print("")
# # Example usage with different currents
# for test_current in [50, 100, 150]:
# calculate_losses(test_current)
import numpy as np
import math
current_range = np.linspace(50, 200, 4)
rows = []
vals = { **cell_spec, **pack_spec, **env_spec, current: current_range}
def round_row(*row):
return [ f"{item:.2f}" for item in row]
headers = ["I (A)", "Out (kW)", "T(overload)", "η (%)", "cell loss (W)", "pack loss (W)"]
rows = compute(vals, [ pack_power, thermal_time, efficiency, cell_power_loss, temp_rise ])
rows[0] = map(lambda x: x/1000, rows[0])
rows[1] = map(format_time, rows[1])
rows[2] = map(int, rows[2])
rows[3] = map(lambda x: f"{x:.2f}", rows[3])
rows[4] = map(lambda x: f"{x:.2f}", rows[4])
[headers, *zip(current_range, *rows)]
| I (A) | Out (kW) | T(overload) | η (%) | cell loss (W) | pack loss (W) |
|---|---|---|---|---|---|
| 50.0 | 3.6 | 1.2h | 97 | 0.55 | 10.30 |
| 100.0 | 7.2 | 18.7min | 95 | 2.19 | 41.19 |
| 150.0 | 10.8 | 8.3min | 92 | 4.92 | 92.68 |
| 200.0 | 14.4 | 4.7min | 90 | 8.75 | 164.76 |
calculate current per cell for each of those
python code block
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator, FuncFormatter, LogLocator
from matplotlib.style import library
print(plt.rcParams.keys())
colors = {
"orange": "#ffa500",
"lightblue": '#adf7f6',
"blue": '#555555',
"red": "#fd5548",
"green": "#73e3bb"
}
print(library['dark_background'])
style = {
**library['dark_background'],
# Frame (spines)
'axes.spines.top': True,
'axes.spines.right': True,
'axes.spines.left': True,
'axes.spines.bottom': True,
'figure.facecolor': (0,0,0,0),
'axes.facecolor': '#111111',
'axes.linewidth': 1.5,
'axes.xmargin': 0.05,
'axes.ymargin': 0.05,
'axes.zmargin': 0.05,
# legend
'legend.fontsize': 'medium',
'legend.title_fontsize': 'medium',
'legend.fancybox': False,
'legend.edgecolor': colors["blue"],
'legend.borderaxespad': 0.5,
# Grid
'axes.edgecolor': colors["blue"],
'axes.labelcolor': colors["green"],
'axes.labelsize': 17,
'axes.grid': True,
'xtick.color': colors["lightblue"],
'ytick.color': colors["lightblue"],
'axes.labelpad': 10,
'xtick.major.pad': 10,
'ytick.major.pad': 10,
'grid.alpha': 0.2,
'grid.linestyle': '-',
'grid.linewidth': 1,
'grid.color': "white",
# Minor grid
'axes.grid.which': 'major', # 'major', 'minor', or 'both'
}
# Setup plot style
plt.style.use(style)
plt.rcParams['font.family'] = 'monospace'
plt.rcParams['font.size'] = 15
# Create figure with multiple subplots
fig, (ax1, ax3) = plt.subplots(2, 1, figsize=(12, 14))
ax2 = ax1.twinx()
# Define current range (starting from small non-zero value)
currents = np.linspace(40, 190, 100)
# Base substitution dictionary (everything except current and cell_ir)
base_subs = {
**pack_spec,
**env_spec,
**{k: v for k, v in cell_spec.items() if k != cell_ir}
}
# Calculate for different internal resistances
for ir_mult in [0.8, 1.0, 1.2, 1.4]:
# Create substitution dictionary with current IR value
ir_value = cell_spec[cell_ir] * ir_mult
# Arrays to store results
pack_losses_arr = []
efficiency_arr = []
time_to_80deg_arr = []
# Calculate values for each current
for current_val in currents:
# Complete substitution dictionary for this calculation
subs = {
**base_subs,
current: current_val,
cell_ir: ir_value
}
# Calculate using SymPy expressions
pack_losses_val = float(pack_power_loss.subs(subs))
efficiency_val = float(efficiency.subs(subs))
thermal_time_val = float(thermal_time.subs(subs))
pack_losses_arr.append(pack_losses_val)
efficiency_arr.append(efficiency_val)
time_to_80deg_arr.append(thermal_time_val)
# Convert to numpy arrays
pack_losses_arr = np.array(pack_losses_arr)
efficiency_arr = np.array(efficiency_arr)
time_to_80deg_arr = np.array(time_to_80deg_arr)
# Plot power losses and efficiency
line1 = ax1.plot(
currents,
pack_losses_arr,
linewidth=2,
label=f'{ir_value*1000:.1f}mΩ'
)
line2 = ax2.plot(
currents,
efficiency_arr,
linewidth=2,
alpha=0.75,
linestyle='--'
)
# Plot time to reach 80°C
line3 = ax3.plot(
currents,
time_to_80deg_arr/60, # Convert to minutes
linewidth=2,
label=f'{ir_value*1000:.1f}mΩ'
)
# Configure top plot
ax1.set_xlabel('Pack Current (A)')
ax1.set_ylabel('Total Heat Generation (W)')
ax2.set_ylabel('Pack Efficiency (%) dashed lines', color=colors["red"])
ax1.axvline(x=150, color=colors["red"], linestyle='--', alpha=0.75, label='Max Power (13kw)')
ax1.axvline(x=100, color=colors["orange"], linestyle='--', alpha=0.75, label='High Power (8.5kw)')
ax1.axvline(x=50, color=colors["green"], linestyle='--', alpha=0.75, label='Normal (4kw)')
# Configure bottom plot
ax3.set_xlabel('Pack Current (A)')
ax3.set_ylabel('Time to reach 80°C')
ax3.set_yscale('log') # Use log scale for time
ax3.yaxis.set_major_formatter(FuncFormatter(format_time))
ax3.yaxis.set_major_locator(LogLocator(base=1.1))
# Add grids
#alpha = 0.5
#ax1.grid(True, which="major", marker="X")
ax2.grid(False)
ax2.spines['top'].set_visible(False)
ax2.spines['right'].set_visible(False)
ax2.spines['bottom'].set_visible(False)
ax2.spines['left'].set_visible(False)
#ax3.grid(True, which="major", ls="-")
#ax3.grid(True, which="minor", ls=":")
ax3.axvline(x=150, color=colors["red"], linestyle='--', alpha=0.75, label='Max Power (13kw)')
ax3.axvline(x=100, color=colors["orange"], linestyle='--', alpha=0.75, label='High Power (8.5kw)')
ax3.axvline(x=50, color=colors["green"], linestyle='--', alpha=0.75, label='Normal (4kw)')
# Set axis intervals
ax1.xaxis.set_major_locator(MultipleLocator(10))
ax1.yaxis.set_major_locator(MultipleLocator(200))
ax3.xaxis.set_major_locator(MultipleLocator(20))
# Add legends
#legend1 = ax1.legend(title='Cell Resistance', loc='upper right')
legend3 = ax3.legend(title='Cell Internal Resistance', loc='upper right')
plt.tight_layout()
# Save and return
plt.savefig('./graph/battery_thermal.svg', dpi=150, bbox_inches='tight', format='svg', transparent=False)
'./graph/battery_thermal.svg'
These are for static air, this seems promising given I create airflow
