Using some of the cellpy special utilities
Open Circuit Relaxation
Note
This chapter would benefit from some more love and care. Any help on that would be highly appreciated.
Plotting selected Open Circuit Relaxation points
# assuming b is a cellpy.utils.batch.Batch object
from cellpy.utils.batch_tools.batch_analyzers import OCVRelaxationAnalyzer
# help(OCVRelaxationAnalyzer)
print(" analyzing ocv relaxation data ".center(80, "-"))
analyzer = OCVRelaxationAnalyzer()
analyzer.assign(b.experiment)
analyzer.direction = "down"
analyzer.do()
dfs = analyzer.last
df_file_one, _df_file_two = dfs
# keeping only the columns with voltages
ycols = [col for col in df_file_one.columns if col.find("point")>=0]
# removing the first ocv rlx (relaxation before starting cycling)
df = df_file_one.iloc[1:, :]
# tidy format
df = df.melt(
id_vars = "cycle", var_name="point", value_vars=ycols,
value_name="voltage"
)
# using holoviews for plotting
curve = hv.Curve(
df, kdims=["cycle", "point"],
vdims="voltage"
).groupby("point").overlay().opts(xlim=(1,10), width=800)
Open Circuit Relaxation modeling
TODO.
Extracting ica data
Note
This chapter would benefit from some more love and care. Any help on that would be highly appreciated.
Example: get dq/dv data for selected cycles
This example shows how to get dq/dv data for a selected cycle. The data is
extracted from the cellpy object using the .get_cap method. The method dqdv_cycle
and the dqdv
methods are cellpy-agnostic and should work also for other
data sources (e.g. numpy arrays).
import matplotlib.pyplot as plt
from cellpy.utils import ica
v4, dqdv4 = ica.dqdv_cycle(
data.get_cap(
4,
categorical_column=True,
method = "forth-and-forth")
)
v10, dqdv10 = ica.dqdv_cycle(
data.get_cap(
10,
categorical_column=True,
method = "forth-and-forth")
)
plt.plot(v4,dqdv4, label="cycle 4")
plt.plot(v10, dqdv10, label="cycle 10")
plt.legend()
Example: get dq/dv data for selected cycles
This example shows how to get dq/dv data directly from the cellpy object. This methodology is more convenient if you want to get the data easily from the cellpy object in a pandas dataframe format.
# assuming that b is a cellpy.utils.batch.Batch object
c = b.experiment.data["20160805_test001_45_cc"] # get the cellpy object
tidy_ica = ica.dqdv_frames(c) # create the dqdv data
cycles = list(range(1,3)) + [10, 15]
tidy_ica = tidy_ica.loc[tidy_ica.cycle.isin(cycles), :] # select cycles
Fitting ica data
TODO.
Using the batch utilities
The steps given in this tutorial describes how to use the new version of the batch utility. The part presented here is chosen such that it resembles how the old utility worked. However, under the hood, the new batch utility is very different from the old. A more detailed guide will come soon.
So, with that being said, here is the promised description.
Starting (setting things up)
A database
Currently, the only supported “database” is Excel (yes, I am not kidding). So, there is definitely room for improvements if you would like to contribute to the code-base.
The Excel work-book must contain a page called db_table
. And the top row
of this page should consist of the correct headers as defined in your cellpy
config file. You then have to give an identification name for the cells you
would like to investigate in one of the columns labelled as batch columns (
typically “b01”, “b02”, …, “b07”). You can find an example of such an Excel
work-book in the test-data.
A tool for running the job
Jupyter Notebooks is the recommended “tool” for running the cellpy batch
feature. The first step is to import the cellpy.utils.batch.Batch
class from cellpy
. The Batch
class is a utility class for
pipe-lining batch processing of cell cycle data.
from cellpy.utils import batch, plotutils
from cellpy import prms
from cellpy import prmreader
The next step is to initialize it:
project = "experiment_set_01"
name = "new_exiting_chemistry" # the name you set in the database
batch_col = "b01"
b = batch.init(name, project, batch_col=batch_col)
and set some parameters that Batch needs:
# setting additional parameters if the defaults are not to your liking:
b.experiment.export_raw = True
b.experiment.export_cycles = True
b.experiment.export_ica = True
b.experiment.all_in_memory = True # store all data in memory, defaults to False
b.save_cellpy_file = True
b.force_raw_file = False
b.force_cellpy_file = True
Extracting meta-data
The next step is to extract and collect the information needed from your data-base into a DataFrame, and create an appropriate folder structure (outdir/project_name/batch_name/raw_data)
# load info from your db and write the journal pages
b.create_journal()
b.create_folder_structure()
Processing data
To run the processing, you should then use the convenience function update
. This function
loads all your data-files and saves csv-files of the results.
b.update()
The next step is to create some summary csv-files (e.g. containing charge capacities vs. cycle number for all your data-files) and plot the results.
b.make_summaries()
b.plot_summaries()
Now it is time to relax and maybe drink a cup of coffee.
Further investigations and analyses
There are several paths to go from here. I recommend looking at the raw data for the different cells briefly to check if everything looks sensible. You can get the names of the different datasets (cells) by issuing:
b.experiment.cell_names
You can get the CellpyCell-object for a given cell by writing:
cell = b.experiment.data[name_of_cell]
plotutils.raw_plot(my_cell)
If you want to investigate further, you can either use one of the available analysis-engines (they work on batch objects processing all the cells at once) or you can continue on a single cell basis (latter is currently recommended).
Another tip is to make new Notebooks for each type of “investigation” you would like to perform. You can load the info-df-file you created in the initial steps, or you could load the individual cellpy-files (if you did not turn off automatic saving to cellpy-format).
You should be able to find examples of processing either by downloading the examples or by looking in the repo.
Collectors
Todo.
Have a look at the data
Note
This chapter would benefit from some more love and care. Any help on that would be highly appreciated.
Here are some examples how to get a peak at the data. If we need an
interactive plot of the raw-data, we can use the plotutils.raw_plot
function. If we would like to see some statistics for some of the
cycles, the plotutils.cycle_info_plot
is your friend. Let´s start by
importing cellpy and the plotutils
utility:
import cellpy
from cellpy.utils import plotutils
Let´s load some data first:
cell = cellpy.get("../testdata/hdf5/20160805_test001_45_cc.h5", mass=0.8)
Here we used the convenience method cellpy.get
to load some
example data. If everything went well, you will see an output approximately
like this:
(cellpy) - Making CellpyCell class and setting prms
(cellpy) - Loading cellpy-file: ../testdata/hdf5/20160805_test001_45_cc.h5
(cellpy) - Setting mass: 0.8
(cellpy) - Creating step table
(cellpy) - Creating summary data
(cellpy) - assuming cycling in anode half-cell (discharge before charge) mode
(cellpy) - Created CellpyCell object
If you have holoviews
installed, you can conjure an
interactive figure:
plotutils.raw_plot(cell)
Sometimes it is necessary to have a look at some statistics for each
cycle and step. This can be done using the cycle_info_plot
method:
fig = plotutils.cycle_info_plot(
cell,
cycle=3,
use_bokeh=False,
)
Note
If you chose to work within a Jupyter Notebook, you are advised to try some of the web-based plotting tools. For example, you might consider installing holoviz suite.
Easyplot
Todo.
Templates
Note
This chapter would benefit from some more love and care. Any help on that would be highly appreciated.
Some info can be found in one of the example notebooks (Example notebooks). It would be more logical if that information was here instead. Sorry for that.
Custom loaders
Todo.