BatterySimulatorBLAST/python/nmc_lto_10Ah_2020.py

177 lines
7.3 KiB
Python
Raw Normal View History

2023-04-08 06:05:55 +09:00
# Paul Gasper, NREL
# This model is fit to data reported by Bank et al from commercial NMC-LTO cells.
# https://doi.org/10.1016/j.jpowsour.2020.228566
import numpy as np
from functions.extract_stressors import extract_stressors
from functions.state_functions import update_power_state
# EXPERIMENTAL AGING DATA SUMMARY:
# Calendar aging varies temperature and SOC. There is almost no calendar aging impact
# at all until 80 Celsius.
# Cycle aging varies temperature, C-rate, and depth-of-discharge.
# MODEL SENSITIVITY
# The model predicts degradation rate versus time as a function of temperature and average
# state-of-charge and degradation rate versus equivalent full cycles (charge-throughput) as
# a function of C-rate, temperature, and depth-of-discharge (DOD dependence is assumed to be linear, no aging data)
# MODEL LIMITATIONS
# Calendar aging has competition between capacity gain and capacity loss. There is an experimental
# case (80 Celsius, 5% SOC) that has complex behavior not modeled here.
# Astonishingly enough, the cycling degradation model is actually _overestimating_ capacity fade for most cases.
# The exception here is at very high temperature (60+ Celsius), where the fade is high, but not quite as high as observed degradation.
class Nmc_Lto_10Ah_Battery:
def __init__(self):
# States: Internal states of the battery model
self.states = {
'qLoss_t': np.array([0]),
'qGain_t': np.array([0]),
'qLoss_EFC': np.array([0]),
}
# Outputs: Battery properties derived from state values
self.outputs = {
'q': np.array([1]),
'q_t_loss': np.array([1]),
'q_t_gain': np.array([1]),
'q_EFC': np.array([1]),
}
# Stressors: History of stressors on the battery
self.stressors = {
'delta_t_days': np.array([np.nan]),
't_days': np.array([0]),
'delta_efc': np.array([np.nan]),
'efc': np.array([0]),
'TdegK': np.array([np.nan]),
'soc': np.array([np.nan]),
'dod': np.array([np.nan]),
'Crate': np.array([np.nan]),
}
# Rates: History of stressor-dependent degradation rates
self.rates = {
'alpha': np.array([np.nan]),
'beta': np.array([np.nan]),
'gamma': np.array([np.nan]),
}
# Nominal capacity
@property
def _cap(self):
return 10.2
# Define life model parameters
@property
def _params_life(self):
return {
# Capacity fade parameters
'alpha_0': 3.11e+11,
'alpha_1': -34.8,
'alpha_2': 1.07,
'alpha_p': 0.473,
'beta_0': 7.86e+10,
'beta_1': -35.8,
'beta_2': 3.94,
'beta_p': -0.553,
'gamma_0': 1.29,
'gamma_1': 7.83e-05,
'gamma_2': 4.02,
'gamma_3': -8.33,
'gamma_p': 0.526,
}
# Battery model
def update_battery_state(self, t_secs, soc, T_celsius):
# Update the battery states, based both on the degradation state as well as the battery performance
# at the ambient temperature, T_celsius
# Inputs:
# t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points
# soc (ndarry): vector of the state-of-charge of the battery at each t_sec
# T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units.
# Check some input types:
if not isinstance(t_secs, np.ndarray):
raise TypeError('Input "t_secs" must be a numpy.ndarray')
if not isinstance(soc, np.ndarray):
raise TypeError('Input "soc" must be a numpy.ndarray')
if not isinstance(T_celsius, np.ndarray):
raise TypeError('Input "T_celsius" must be a numpy.ndarray')
if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)):
raise ValueError('All input timeseries must be the same length')
self.__update_states(t_secs, soc, T_celsius)
self.__update_outputs()
def __update_states(self, t_secs, soc, T_celsius):
# Update the battery states, based both on the degradation state as well as the battery performance
# at the ambient temperature, T_celsius
# Inputs:
# t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points
# soc (ndarry): vector of the state-of-charge of the battery at each t_sec
# T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units.
# Extract stressors
delta_t_secs = t_secs[-1] - t_secs[0]
delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius)
TdegKN = TdegK / (273.15 + 45)
# Grab parameters
p = self._params_life
# Calculate the degradation coefficients
alpha = p['alpha_0'] * np.exp(p['alpha_1']/TdegKN) * np.exp(p['alpha_2']*soc/TdegKN)
beta = p['beta_0'] * np.exp(p['beta_1']/TdegKN) * np.exp(p['beta_2']*soc/TdegKN)
gamma = (
(p['gamma_0'] + p['gamma_1']*Crate + p['gamma_2']*(dod**3))
* np.exp(p['gamma_3']/TdegKN)
)
# Calculate time based average of each rate
alpha = np.trapz(alpha, x=t_secs) / delta_t_secs
beta = np.trapz(beta, x=t_secs) / delta_t_secs
gamma = np.trapz(gamma, x=t_secs) / delta_t_secs
# Calculate incremental state changes
states = self.states
# Capacity
dq_t_gain = update_power_state(states['qGain_t'][-1], delta_t_days, alpha, p['alpha_p'])
dq_t_loss = update_power_state(states['qLoss_t'][-1], delta_t_days, beta, p['beta_p'])
dq_EFC = update_power_state(states['qLoss_EFC'][-1], delta_efc, gamma, p['gamma_p'])
# Accumulate and store states
dx = np.array([dq_t_loss, dq_t_gain, dq_EFC])
for k, v in zip(states.keys(), dx):
x = self.states[k][-1] + v
self.states[k] = np.append(self.states[k], x)
# Store stressors
t_days = self.stressors['t_days'][-1] + delta_t_days
efc = self.stressors['efc'][-1] + delta_efc
stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc), dod, Crate])
for k, v in zip(self.stressors.keys(), stressors):
self.stressors[k] = np.append(self.stressors[k], v)
# Store rates
rates = np.array([alpha, beta, gamma])
for k, v in zip(self.rates.keys(), rates):
self.rates[k] = np.append(self.rates[k], v)
def __update_outputs(self):
# Calculate outputs, based on current battery state
states = self.states
# Capacity
q_t_loss = 1 - states['qLoss_t'][-1]
q_t_gain = 1 + states['qGain_t'][-1]
q_EFC = 1 - states['qLoss_EFC'][-1]
q = 1 - states['qLoss_t'][-1] + states['qGain_t'][-1] - states['qLoss_EFC'][-1]
# Assemble output
out = np.array([q, q_t_loss, q_t_gain, q_EFC])
# Store results
for k, v in zip(list(self.outputs.keys()), out):
self.outputs[k] = np.append(self.outputs[k], v)