Modeling the operation of a cell from real world energy storage system data

[jhthompson12]

Background

Hi there, Im a stationary energy storage researcher in the electric utility space and I am very interested in PyBaMM, though much of the electrochemistry and physics in these models goes a bit over my head.

I have 6 years of data from a large storage system (think large shipping containers filled with racks, filled with modules, filled with cells) where we have developed our own characterization of the degradation of this system over the years by analyzing periodic reference performance test data.

I would like to use some or all of this data (mainly historical current and temperature timeseries) as the input to a PyBaMM model to see how these models show degradation under the same cycling and ambient conditions as the real system.

So far I have had luck getting everything installed and am working with just a 1 hour snippet of my real system current data. Im trying to input this to a simple NMC model and, if everything worked out, I am hoping that PyBaMM would roughly model the same operation that I see in the real data for this 1-hour time period.

Unfortunately, the simulation only makes it about 30 minutes into the cycling before stopping, it does not error out, but the simulation data just ends at around 1700 seconds.

Some details about the real system I am trying to model

• I have 10 second resolution data at the rack level for this system. Each Rack consists of 17 module. Each Module contains 28 LG Chem JH3 cells in a 14S2P configuration
• To get the cell-level current from the rack-level current data that I have I just divide rack-level current by 2 before handing the current profile off to the PyBaMM model
• I am using the Mohtat2020 parameters as a starting point because it is listed as NMC, which is the same as my real cells. Then I adjust some of those parameters to match specs of the JH3 cells

My Script

import pybamm
import matplotlib as mpl
import pandas as pd  # needed to read the csv data file
import plotly.graph_objs as go
from plotly.offline import plot
from plotly.subplots import make_subplots

mpl.use('TkAgg')  # or can use 'TkAgg', whatever you have/prefer

# import drive cycle data from file
all_data = pd.read_pickle("../Create Sample Data/Data/2017-2018_Rack1_Data.pickle")

# extract smaller portion of data
start = pd.to_datetime("2017-09-22 00:00:00")
end = pd.to_datetime("2017-09-22 01:00:00")

smaller_data = all_data.loc[start:end][[
    'Container 1, Rack 1_StateOfCharge',
    'Container 1, Rack 1_DC.Voltage_Avg of Cells',
    'Container 1, Rack 1_Temp.Battery.Module_Avg of Modules',
    'Container 1, Rack 1_DC.Current'
]]

# The rack from which this data originates is made of 17 modules (in series), where each module contains 28 cells in a
# 14S2P configuration. So, to get the cell-level current we divide the rack-level current by 2
smaller_data["Cell Current"] = smaller_data['Container 1, Rack 1_DC.Current'] / -2  # the sign convention might be backwards, so flip it

# create a seconds column
smaller_data["Seconds"] = (smaller_data.index - start).total_seconds()

drive_cycle = smaller_data[["Seconds", "Cell Current"]].to_numpy()

# Instantiate a simple model
model = pybamm.lithium_ion.DFN()

# load parameter values
param = model.default_parameter_values

# get predefined parameters for an NMC cell
param_mohtat = pybamm.ParameterValues("Mohtat2020")

# apply the SoC / Voltage relationship data from analyzing the real system data
param_mohtat["Open-circuit voltage at 0% SOC [V]"] = 3.2
param_mohtat["Open-circuit voltage at 100% SOC [V]"] = 4.17
param_mohtat["Upper voltage cut-off [V]"] = 4.2
# nominal capacity for JH3 cells (and a few other parameters) from LG Chem documentation
param_mohtat["Nominal cell capacity [A.h]"] = 63
param_mohtat["Cell volume [m3]"] = 5.65e-04
param_mohtat["Lower voltage cut-off [V]"] = 3

# create interpolant - must be a function of *dimensional* time
current_interpolant = pybamm.Interpolant(drive_cycle[:, 0], drive_cycle[:, 1], pybamm.t)

# set drive cycle
param_mohtat["Current function [A]"] = current_interpolant

output_variables = [
    'Voltage [V]',
    'Current [A]',
]

# set up simulation - for drive cycles we recommend using the CasadiSolver in "fast" mode
solver = pybamm.CasadiSolver(mode="fast")
simulation = pybamm.Simulation(model, parameter_values=param_mohtat)

# simulate US06 drive cycle (duration 600 seconds)
initial_soc = smaller_data['Container 1, Rack 1_StateOfCharge'].iloc[0] / 100
simulation.solve(initial_soc=initial_soc, showprogress=True)

solution = simulation.solution

# combine solution data for later plotting
solution_data = pd.concat([pd.Series(solution[var].entries, index=solution.t, name=var) for var in output_variables], axis=1)

# plot
# combine simulation data back into original EW Brown data
plot_data = pd.concat([smaller_data.reset_index().set_index("Seconds"), solution_data], axis=1)
plot_data = plot_data.loc[~plot_data["index"].isna()]

fig = make_subplots(rows=2, cols=1, shared_xaxes=True)

fig.add_trace(
    go.Scattergl(
        x=plot_data["index"],
        y=plot_data['Current [A]'],
        name='Cell Current (Rack Current / 2)',
        mode="lines",
        line=dict(width=1)
    ), row=1, col=1
)

fig.add_trace(
    go.Scattergl(
        x=plot_data["index"],
        y=plot_data['Container 1, Rack 1_DC.Voltage_Avg of Cells'],
        name='Rack Avg Cell Voltage',
        mode="lines",
        line=dict(width=1)
    ), row=2, col=1
)

fig.add_trace(
    go.Scattergl(
        x=plot_data["index"],
        y=plot_data['Voltage [V]'],
        name="Modeled Cell Voltage",
        mode="lines",
        line=dict(width=1)
    ), row=2, col=1
)

fig.update_layout(
    yaxis=dict(title="Cell Current (A)"),
    yaxis2=dict(title="Cell Voltage (V)"),
    # yaxis3=dict(title="AmpHours")
)

plot(fig, filename="Plots/Real_vs_Modeled_Voltage.html")

Simulation Results

Final Questions

• Does what Im attempting to do even make sense?
• If so, how can I improve upon what I have tried already? Maybe different models? Maybe customizing more of the parameters?

Thanks in advance for any feedback!

[TomTranter]

Hi, it doesn't seem like you're doing anything wrong with the model but it's odd that if you give it a longer time series the sim stops with no error. I didn't have your file but this looks almost right for the current and scripts runs ok

import pybamm
import matplotlib.pyplot as plt
import numpy as np

# Define the minute-by-minute values from the table provided
current_values = [
    -1, -3, -5, -4, -3, -1, 1, 3, 4, 2, -1, -3, -5, -7, -9, -10, -8, -6, -4, -3,
    0, 2, 5, 8, 10, 10, 9, 7, 5, 2, -2, -5, -8, -11, -12, -11, -9, -7, -5, -3,
    -1,
]

# Convert the list to a numpy array
current_array = np.array(current_values)
time_array = np.arange(0, len(current_array))*60

plt.figure()
plt.plot(current_array)

# Instantiate a simple model
model = pybamm.lithium_ion.DFN()

# load parameter values
param = model.default_parameter_values

# get predefined parameters for an NMC cell
param_mohtat = pybamm.ParameterValues("Mohtat2020")

# apply the SoC / Voltage relationship data from analyzing the real system data
param_mohtat["Open-circuit voltage at 0% SOC [V]"] = 3.2
param_mohtat["Open-circuit voltage at 100% SOC [V]"] = 4.17
param_mohtat["Upper voltage cut-off [V]"] = 4.2
# nominal capacity for JH3 cells (and a few other parameters) from LG Chem documentation
param_mohtat["Nominal cell capacity [A.h]"] = 63
param_mohtat["Cell volume [m3]"] = 5.65e-04
param_mohtat["Lower voltage cut-off [V]"] = 3

# create interpolant - must be a function of *dimensional* time
current_interpolant = pybamm.Interpolant(time_array, current_array, pybamm.t)

# set drive cycle
param_mohtat["Current function [A]"] = current_interpolant

output_variables = [
    'Voltage [V]',
    'Current [A]',
]


solver = pybamm.CasadiSolver(mode="fast")
simulation = pybamm.Simulation(model, parameter_values=param_mohtat)

simulation.solve(initial_soc=0.5, showprogress=True)
solution = simulation.solution

solution.plot()

[TomTranter]

Although changing the nominal cell capacity will have little effect. You need to adjust electrode dimensions to change actual capacity. That's probably why your voltages are changing more than you expect

[jhthompson12]

Thank you for the reply!

I think you're right about the electrode dimensions specfication. I only changed the Nominal cell capacity [A.h] to 63 and
Cell volume [m3] to 5.65e-04, so i guess the model still effectively has the 5Ah capacity from the Mohtat2020 parameters, which would definitely explain the larger changes in voltage for a given amount of charge compared to my 63Ah cell.

Im trying to think through a way to proceed. PyBaMM does not already have a predefined set of parameters for the specific LG Chem JH3 cells for which I have real data. So, I can think of 2 ways forward:

• Option 1: Try to create my own set of custom parameters that closely describe the JH3 cells that I have.

  • The problem with this is that I have very limited information about the cells internal design, I basically just have the high-level information from public documentation:
    

• Option 2: Try just using the most similar predefined parameters from PyBaMM (basically any NMC parameters like Mohtat2020) and scale the current such that the modeled cell is experiencing a similar amount of stress from a C-rate perspective.

  • To create the current that the modeled 5Ah cell should experience I would divide the JH3 current by 63Ah to get the C-rate and then multiply by 5Ah. This would become the current input for the simulation.

@TomTranter, do you have any thoughts about these approaches? Im going to try option 2 here soon.

To reiterate, my true end goal is run a few NMC PyBaMM models through simulations using the 6 years of cell current and ambient temperature data that I have from this real system. I would then extract the discharge energy capacity / state of health data from the simulations and compare them to the known degradation that the real system experienced.

Bonus Questions!

Lmk if i should move these to separate Q&A threads.

• The simulation was stopping at around 1700 seconds but printed nothing to the console. I suspect it was stopping because the modeled 5Ah cell reached it's top of charge and was being asked to continue charging. Is there some kind of verbose flag for the simulation / solver to be able to better know the status of the simulation?
• Any thoughts on actually running this model with the full 6 years of 10-second current and temperature data that I have? I could see this being problematic..

[jhthompson12]

Option 2 seems to work decently enough, at least at small timescales, like one hour.

Im now running into trouble with longer term simulations (multiple days) where the error between the modeled cell and real cell voltages increases until the modeled cell reaches top of charge stopping the simulation. I think I'll ask a more pointed question in a new thread.

[TomTranter]

Are you in the pybamm slack channel? Prof David Howey would be a great person to ask about best approaches for analysing field data with limited info. My instinct is that physics based models might not be the best starting point. Maybe also @valentinsulzer has an opinion

[TomTranter]

I just reread that you do have rpt cycles. Have you tried or had any luck fitting the model to any of these?