From 07ea85eddfbcd8992a381cc4895fcc412d3bab19 Mon Sep 17 00:00:00 2001 From: Sravan Pannala <57152030+sravanpannala@users.noreply.github.com> Date: Thu, 22 Feb 2024 09:13:29 -0500 Subject: [PATCH] add matab code for esoh and aging metrics for cycling aging --- .../Degradation_estimation_Jason_RRC_csm.m | 242 +++++++++ gmproj/matlab/Dis_relax_time.m | 33 ++ gmproj/matlab/Peyman_HPPC_toSravan.m | 126 +++++ ...nostics_GMJuly22_Dischargeonly_july4_csm.m | 66 +++ gmproj/pressure/organize_data.ipynb | 484 ++++++++++++++++++ 5 files changed, 951 insertions(+) create mode 100644 gmproj/matlab/Degradation_estimation_Jason_RRC_csm.m create mode 100644 gmproj/matlab/Dis_relax_time.m create mode 100644 gmproj/matlab/Peyman_HPPC_toSravan.m create mode 100644 gmproj/matlab/diagnostics_GMJuly22_Dischargeonly_july4_csm.m create mode 100644 gmproj/pressure/organize_data.ipynb diff --git a/gmproj/matlab/Degradation_estimation_Jason_RRC_csm.m b/gmproj/matlab/Degradation_estimation_Jason_RRC_csm.m new file mode 100644 index 0000000000..0991ae0263 --- /dev/null +++ b/gmproj/matlab/Degradation_estimation_Jason_RRC_csm.m @@ -0,0 +1,242 @@ +%Andrew degradation calculation +% clearvars -except partt +clear +close all +load("param41.mat") +partt=param41; +% close all + +set(groot,'defaultAxesXGrid','on') +set(groot,'defaultAxesYGrid','on') + +%% +% +% discharge_list=["",... +% "GMJuly2022_CELL016_RPT_3_P25C_5P0PSI_20230103_R0_CH039_20230103170220_36_2_4_2818579475_DISCHARGE.csv",... +% "GMJuly2022_CELL016_RPT_3_P25C_5P0PSI_20230213_R0_CH012_20230213130718_36_2_4_2818579481_DISCHARGE.csv",... +% "GMJuly2022_CELL016_RPT_3_P25C_5P0PSI_20230309_R0_CH012_20230309091051_36_2_4_2818579483_DISCHARGE.csv",... +% "GMJuly2022_CELL016_RPT_3_P25C_5P0PSI_20230404_R0_CH012_20230404091003_36_2_4_2818579492_DISCHARGE.csv",... +% "GMJuly2022_CELL016_RPT_3_P25C_5P0PSI_20230501_R0_CH012_20230501123929_36_2_4_2818579504_DISCHARGE.csv",... +% ]; + +% discharge_list=["",... +% "GMJuly2022_CELL088_RPT_4B_1_P25C_5P0PSI_20221007_R0_CH014_20221007162958_36_2_6_2818579453_DISCHARGE.csv",... +% "GMJuly2022_CELL088_RPT_1_P25C_5P0PSI_20221114_R0_CH014_20221115071211_36_2_6_2818579467_DISCHARGE.csv",... +% "GMJuly2022_CELL088_RPT_3_P25C_5P0PSI_20221213_R0_20221213155616_36_2_6_2818579473_DISCHARGE.csv",... +% "GMJuly2022_CELL088_RPT_3_P25C_5P0PSI_20230213_R0_CH014_20230213130510_36_2_6_2818579480_DISCHARGE.csv",... +% "GMJuly2022_CELL088_RPT_3_P25C_5P0PSI_20230331_R0_CH014_20230331114523_36_2_6_2818579490_DISCHARGE.csv",... +% "GMJuly2022_CELL088_RPT_3_P25C_5P0PSI_20230519_R0_CH014_20230519143056_36_2_6_2818579508_DISCHARGE.csv"]; + +% discharge_list=["",... +% "GMJuly2022_CELL081_RPT_1_P25C_5P0PSI_20221007_R0_CH018_20221007163459_36_3_2_2818579454_DISCHARGE.csv",... +% "GMJuly2022_CELL081_RPT_1_P25C_5P0PSI_20221114_R0_CH018_20221115071355_36_3_2_2818579467_DISCHARGE.csv",... +% "GMJuly2022_CELL081_RPT_3_P25C_5P0PSI_20221214_R0_CH018_20221214161546_36_3_2_2818579474_DISCHARGE.csv",... +% "GMJuly2022_CELL081_RPT_3_P25C_5P0PSI_20230213_R0_CH018_20230213133903_36_3_2_2818579480_DISCHARGE.csv"]; + +discharge_list=["",... + "GMJuly2022_CELL041_RPT_1_P25C_5P0PSI_20221007_R0_CH017_20221007163327_36_3_1_2818579453_DISCHARGE.csv",... + "GMJuly2022_CELL041_RPT_1_P25C_5P0PSI_20221115_R0_CH017_20221115071316_36_3_1_2818579467_DISCHARGE.csv",... + "GMJuly2022_CELL041_RPT_3_P25C_5P0PSI_20221214_R0_CH017_20221214161410_36_3_1_2818579474_DISCHARGE.csv",... + "GMJuly2022_CELL041_RPT_3_P25C_5P0PSI_20230213_R0_CH017_20230213133637_36_3_1_2818579480_DISCHARGE.csv",... + "GMJuly2022_CELL041_RPT_3_P25C_5P0PSI_20230331_R0_CH017_20230331115026_36_3_1_2818579490_DISCHARGE.csv"]; + +Cn_intial_39=[4.47, 4.37, 4.28, 4.26, 4.25]; +C_39=[3.54, 3.47, 3.4, 3.36, 3.33]; + +% Cn_initial_39= +Xi=[.0;3.7;0.82;4.00;5;0;0]; + +% Xi=[0.2;4.5;1;3.5]; +%% +Xt2=zeros(7,2); +%% +Xt2(:,1)=Xi; +% +for i=2:length(discharge_list) +data=readmatrix(discharge_list{i}); +% data=readmatrix(charge_list{i}); + +Dis(i).Q=data(2:end,5); Dis(i).V=data(2:end,4); +% Dis(i).Q=data(2:end,2); Dis(i).V=data(2:end,3); + +Dis(i).Q=max(Dis(i).Q)-Dis(i).Q; +tempQ=Dis(i).Q; tempV=Dis(i).V; +Dis(i).Q=Dis(i).Q(tempV>=2.65 & tempQ>.01); +Dis(i).V=Dis(i).V(tempV>=2.65 & tempQ>.01); +Dis(i).Q=Dis(i).Q-Dis(i).Q(end); + +%% Create RRC voltage +clear Time t aa yout +Cell_table=readtable(discharge_list{i}); +aI=0.175; +Date=Cell_table(tempV>=2.65 & tempQ>.01,2); +aa=Date{:,1}; +Dis(i).t=datetime(aa,'InputFormat','yyyy-MM-dd HH:mm:ssXXXX','TimeZone','America/New_York'); +Dis(i).days=Dis(i).t; +Dis(i).t=Dis(i).t-Dis(i).t(1); +Dis(i).Time=seconds(Dis(i).t); + +R1=partt(i).R1; R2=partt(i).R2; Rs=partt(i).RS; +tau1_hat=partt(i).tau1_hat; tau2_hat=partt(i).tau2_hat; + +for k=1:length(Dis(i).Time) + Dis(i).yout(k)=Rs*aI ... + +aI*R1*(1-exp(-(Dis(i).Time(k))/tau1_hat))... + +aI*R2*(1-exp(-(Dis(i).Time(k))/tau2_hat)); + +end + +% figure(25); plot(Dis(i).Time,Dis(i).yout); +%% + + +% IC_con=Xt2(:,i-1); +IC_con=Xi(1:4); + +% IC_con(4)=Cn_intial_04(i-1); +% IC_con(3)=C_91(i-1)/Cn_intial_39(i-1)+.02; + +% [Xt2(:,i),fval2(i)] = diagnostics_GMJuly22_ch(Dis(i).Q,Dis(i).V,Xi,Xt2(:,i-1)) +[Xt2(1:4,i),fval2(i)] = diagnostics_GMJuly22_Dischargeonly_july4_csm(Dis(i).Q,Dis(i).V+Dis(i).yout',Xi(1:4),IC_con) +faval_rmse(i)=sqrt(fval2(i)/length(Dis(i).Q)); + +% +Qtot2(i)=max(Dis(i).Q); + +Dis(i).V_tt =NMC622_discharge_June15(Xt2(1,i)+Dis(i).Q/Xt2(2,i))-Un_Graphite_Andrew_top(Xt2(3,i)-Dis(i).Q/Xt2(4,i)); +% Dis(i).V_tt =Up_NMC622_notshifted(Xt2(1,i)+Dis(i).Q/Xt2(2,i))-Un_Graphite(Xt2(3,i)-Dis(i).Q/Xt2(4,i)); +% Dis(i).V_tt =Up_NMC622_man_shifted(Xt2(1,i)+Dis(i).Q/Xt2(2,i))-Un_Graphite(Xt2(3,i)-Dis(i).Q/Xt2(4,i)); + +Xt2(5,i)=Qtot2(i); +Xt2(6,i)=Xt2(1,i)+Qtot2(i)/Xt2(2,i); +Xt2(7,i)=Xt2(3,i)-Qtot2(i)/Xt2(4,i); + + +% figure(2);hold on; plot(Dis(i).Q,Dis(i).V+Dis(i).yout',LineWidth=2); +% plot(Dis(i).Q,Dis(i).V_tt,":k") + + % plot(max(Dis(i).Q)-Dis(i).Q,Dis(i).V_tt,":k",LineWidth=2) + + +%% DVDQ + +%Using RRC corredcted voltage for dvdq +Dis(i).VRRC_correc=Dis(i).V+Dis(i).yout'; + +[Dis(i).Quniq,ia,ic]=unique(Dis(i).Q); +Dis(i).Vuniq=Dis(i).V(ia); +Dis(i).Vcor_uniq=Dis(i).VRRC_correc(ia); + +dQ=5e-3; +Dis(i).Qint=0:dQ:3.6; +Dis(i).Vint_unfitered=interp1(Dis(i).Quniq,Dis(i).Vuniq,Dis(i).Qint); +Dis(i).Vcor_int=interp1(Dis(i).Quniq,Dis(i).Vcor_uniq,Dis(i).Qint); + +% +num_no_nans(i) = sum(~isnan(Dis(i).Vint_unfitered)); +Num_of_nans(i)=length(Dis(i).Vint_unfitered)-num_no_nans(i); + +% Dis(i).Vint=lowpass(Dis(i).Vint_unfitered(1:num_no_nans(i)),1/1/dQ,1/dQ); +Dis(i).Qnnan=Dis(i).Qint(1:num_no_nans(i)); +Dis(i).Vnnan=Dis(i).Vint_unfitered(1:num_no_nans(i)); + +Dis(i).Vno_nan=Dis(i).Vint_unfitered(~isnan(Dis(i).Vint_unfitered)); +Dis(i).Vno_nan_cor=Dis(i).Vcor_int(~isnan(Dis(i).Vcor_int)); + +Dis(i).Qno_nan=Dis(i).Qint(~isnan(Dis(i).Vint_unfitered)) + +Frameleng=21; +[b,g] = sgolay(5,Frameleng); + +Dis(i).V_SG= sgolayfilt(Dis(i).Vno_nan_cor,5,Frameleng); + + +for j=1+5:num_no_nans(i)-5 + Dis(i).Vint= Dis(i).V_SG; + + Dis(i).dvdq(j)= [-2, +25, -150, 600, -2100, 0, 2100, -600, 150, -25, 2]/2520*... + [Dis(i).Vint(j-5); Dis(i).Vint(j-4); Dis(i).Vint(j-3);Dis(i).Vint(j-2);Dis(i).Vint(j-1);Dis(i).Vint(j);... + Dis(i).Vint(j+1);Dis(i).Vint(j+2);Dis(i).Vint(j+3);Dis(i).Vint(j+4);Dis(i).Vint(j+5)]/dQ ; +end + +Dis(i).dvdq_filtered=Dis(i).dvdq; + + +Dis(i).yout_uniq=Dis(i).yout(ia); + +weight_error=zeros(1,length(Dis(i).dvdq(Frameleng:num_no_nans(i)-Frameleng))); +weight_error(Frameleng:end-Frameleng)=1; + +[Dis(i).Vmodel, Dis(i).dvdqmodel]=model_V_dvdq(Xt2(1:4,i), Dis(i).Qnnan',Dis(i).Vnnan',Dis(i).dvdq); + + +Dis(i).yout_interp=interp1(Dis(i).Quniq, Dis(i).yout_uniq, Dis(i).Qnnan); + +figure(i); +hold on; +plot(Dis(i).Qnnan(Frameleng:end-Frameleng-5), Dis(i).dvdqmodel(Frameleng:end-Frameleng)); +plot(Dis(i).Qnnan(Frameleng:end-Frameleng-5), Dis(i).dvdq(Frameleng:end-Frameleng)); +legend("model", "data") + + +figure(i+10); +hold on; +plot(Dis(i).Qnnan,flipud(Dis(i).Vmodel)'-Dis(i).yout_interp); +plot(Dis(i).Qnnan,Dis(i).Vnnan); +legend("model", "data") + +Dis(i).error_dvdq=weight_error.*(Dis(i).dvdq(Frameleng:num_no_nans(i)-Frameleng)-Dis(i).dvdqmodel(Frameleng:num_no_nans(i)-Frameleng)); +Dis(i).error_V=Dis(i).Vnnan-flipud(Dis(i).Vmodel)'+Dis(i).yout_interp; + +rmseV(i)=rms(Dis(i).error_V); +rmsedVdQ(i)=rms(Dis(i).error_dvdq); + + + + + + + +end +%% + cycles=[1;2;3;4;5]; + +TOCSV=["Cycle", "x_0", "y_0", "x_100", "y_100","C_n","C_p","Cap", NaN, NaN, "rmse Voltage","rmse dvdq";... +cycles, Xt2(7,2:end)', Xt2(6,2:end)', Xt2(3,2:end)' , Xt2(1,2:end)', Xt2(4,2:end)', Xt2(2,2:end)' ,... + Xt2(5,2:end)', NaN*ones(length(discharge_list)-1,1), NaN*ones(length(discharge_list)-1,1),rmseV(2:end)',rmsedVdQ(2:end)']; + + + +% TOCSV=[cyc',Ah_thru',xxt2' ,Qtot2(2:13)', (fval2(2:end))']; + +% TOCSV=["Cycle", "x_0", "y_0", "x_100", "y_100","C_n","C_p","Cap", NaN, NaN, "Fit error x 10";... +% cycles, Xt2(7,2:end)', Xt2(6,2:end)', Xt2(3,2:end)' , Xt2(1,2:end)', Xt2(4,2:end)', Xt2(2,2:end)' ,... +% Xt2(5,2:end)', NaN*ones(length(discharge_list)-1,1), NaN*ones(length(discharge_list)-1,1),faval_rmse(2:end)']; + +writematrix(TOCSV,"C:\Users\Hamid\Desktop\Simona\Rsults NMC\cell041_1D_Andrewtop.csv"); + +%% Reconstruct + +function [vmodel,dvdq_model]=model_V_dvdq(X,Q,Vt_data,dVdQ) + +Q = flipud(max(Q)-Q); + +dQ=5e-3; + +V1=NMC622_discharge_June15(X(1)+Q/X(2))-Un_Graphite_Andrew_top(X(3)-Q/X(4)); + +V = flipud(V1); + +for j=1+5:length(Vt_data)-5 + dvdq_model(j)= [-2, +25, -150, 600, -2100, 0, 2100, -600, 150, -25, 2]/2520*... + [V(j-5); V(j-4); V(j-3);V(j-2);V(j-1);V(j);... + V(j+1);V(j+2);V(j+3);V(j+4);V(j+5)]/dQ ; +end + + +% verror=V-Vt_data; +% dvdq_error=dvdq_model-dVdQ; +vmodel=V1; + + +end \ No newline at end of file diff --git a/gmproj/matlab/Dis_relax_time.m b/gmproj/matlab/Dis_relax_time.m new file mode 100644 index 0000000000..f8dfdaa074 --- /dev/null +++ b/gmproj/matlab/Dis_relax_time.m @@ -0,0 +1,33 @@ +%% Finding discharge relaxation points +function [Init,Endit]=Dis_relax_time(data) + +pulse_amp=2000; + +Time0=data(:,1); I0=data(:,2); Vt0=data(:,3); %current(mA) +Cyc_num=data(:,11); + +Cyc_uniq=unique(Cyc_num); + +%% In each cycle +Init=[]; +for i=1:length(Cyc_uniq) + + Time=Time0(Cyc_num==Cyc_uniq(i)); + I=I0(Cyc_num==Cyc_uniq(i)); + I_diff=diff(I); +% figure(i);plot(Time,I) + + indices0=find(I_diff>pulse_amp-600 & I_diffInit(jj,ii) & TimeInit(jj,ii) & TimeInit(jj,ii) & Timetau2_hat); +temp=tau1_hat; +temp2=R1; +tau1_hat(A_in)=tau2_hat(A_in); +R1(A_in)=R2(A_in); +tau2_hat(A_in)=temp(A_in); +R2(A_in)=temp2(A_in); + +%% Nan; +tau1_hat(exitflag==0)=NaN;tau2_hat(exitflag==0)=NaN; +R1(exitflag==0)=NaN; R2(exitflag==0)=NaN; Rs(exitflag==0)=NaN; +Rtottau2_hat(exitflag==0)=NaN; + +%% +cell_str = num2str(HP_i,'%02.f'); +file_name = strcat('r_rc/r_rc_data_cell_',cell_str,'.mat'); +save(file_name,"Rs","R1","R2","tau1_hat","tau2_hat","RMSEE") + +% close all +end + + +%% +function plt_lgnd(Cyc_uniq) +strings={}; +for i=1:2:length(Cyc_uniq) + strings=[strings, {"Cycle:"+num2str(Cyc_uniq(i))}]; +end +legend(strings) +end +%} +function ax= plot_gca(newcolors) +set(gcf,'DefaultAxesColorOrder', newcolors,... + 'DefaultAxesLineStyleOrder',{'-','--',':','-.'}) +ax = gca; +end + +function y= Jerror(x,Vt,Time,tau_coef, I1) +tau1_hat=x(1); +R1=x(2); +tau2_hat=x(3); +R2=x(4); +Rs=x(5); + +aI=-1*I1(1)/1000; +I12= (I1-I1(1))/1000; + +y=barrierPenalty(tau1_hat,0,5000,10,0); +y=y+barrierPenalty(tau2_hat,0,5000,10,0); +% y=y+barrierPenalty(tau2_hat-tau_coef*tau1_hat,0,2000,10,0); % tau2>coef*tau1 +y=y+barrierPenalty(Rs,0,1e3,10,0); %R=R*1000 %Rs>0 +y=y+barrierPenalty(R1,0,1e3,10,0); %R=R*1000 +y=y+barrierPenalty(R2,0,1e3,10,0); %R=R*1000 %R2>0 + for k=1:length(Time) + y=y+(Vt(k)-Vt(1)-Rs*I12(k)/1000.... + -aI*R1/1000*(1-exp(-(Time(k)-Time(1))/tau1_hat))... + -aI*R2/1000*(1-exp(-(Time(k)-Time(1))/tau2_hat)))^2; + + end +end diff --git a/gmproj/matlab/diagnostics_GMJuly22_Dischargeonly_july4_csm.m b/gmproj/matlab/diagnostics_GMJuly22_Dischargeonly_july4_csm.m new file mode 100644 index 0000000000..394ee68e48 --- /dev/null +++ b/gmproj/matlab/diagnostics_GMJuly22_Dischargeonly_july4_csm.m @@ -0,0 +1,66 @@ +function [Xr,fval] = diagnostics_GMJuly22_Dischargeonly_july4_csm(Q_data,Vt_data,Xi,bound) + +Ctilde=max(Q_data); + + + +% V = @(X,Q) Up_NMC622_notshifted(X(1)+Q/X(2))-Un_Graphite(X(3)+Q/X(4)); % charge Q>0 +% V = @(X,Q) Up_NMC622_notshifted_dis_May18_3(X(1)+Q/X(2))-Un_Graphite_Dis_GM1(X(3)-Q/X(4)); + V = @(X,Q) NMC622_discharge_June15(X(1)+Q/X(2))-Un_Graphite_Andrew_top(X(3)-Q/X(4)); + +Vt_data = flipud(Vt_data); +Q_data = flipud(max(Q_data)-Q_data); + + + +% S = [20;1/6;1;1/6;1]; + + +% Xi(2) = Xi(2)*0.92; +% Xi(4) = Xi(4)*0.92; + + +% fun = @(X) (V(X,Q_data)-Vt_data)'*(V(X,Q_data)-Vt_data)... +% +barrierPenalty(Up_NMC622_notshifted_dis_May18_3(X(1))-Un_Graphite_Dis_GM1(X(3)),4.1,4.3,0,0.01)... +% +barrierPenalty(Up_NMC622_notshifted_dis_May18_3(Ctilde/X(2)+X(1))-Un_Graphite_Dis_GM1(-Ctilde/X(4)+X(3)), 2.6,2.8,0,0.01); +fun = @(X) (V(X,Q_data)-Vt_data)'*(V(X,Q_data)-Vt_data); + + + +% +barrierPenalty(Up_NMC622_man_shifted(X(1))-Un_Graphite(X(3)),4.1,4.3,.05,0.01)... +% +barrierPenalty(Up_NMC622_man_shifted(Ctilde/X(2)+X(1))-Un_Graphite(-Ctilde/X(4)+X(3)), 2.9,3.1,.05,0.01); +% options = optimoptions('fmincon','ScaleProblem',true,'StepTolerance',1e-20,'MaxIter',1e4, 'MaxFunEvals', 1e5, 'PlotFcn','optimplotfval'); +% options = optimoptions('paretosearch',ScaleProblem',true,'StepTolerance',1e-20,'MaxIter',1e4, 'MaxFunEvals', 1e4, 'PlotFcn','psplotbestf'); + +% options = optimset('TolX',1e-10,'TolFun',1e-10,'MaxIter',1e4, 'MaxFunEvals', 1e5, 'PlotFcns','psplotbestf'); +% options = optimset('TolX',1e-10,'TolFun',1e-10,'MaxIter',1e4, 'MaxFunEvals', 1e5,'plotFcns','gaplotbestf'); + + + +% [Xr,fval,exitflag] = fminsearch(fun,Xi,options) ; +% [Xr,fval,exitflag] = ga(fun,4,[],[],[],[],[-.1, 2, 0.5,2 ],[ 0.1, bound(2)+0.5, bound(3)+.2, bound(4)+0.5],[],options) ; +% [Xr,fval,exitflag] = patternsearch(fun,bound,[],[],[],[],[-0.1, 2, 0.5,2 ],[ 0.3, bound(2)+0.5, 1, bound(4)+0.5],[],options) ; +ub=[0.1, 5, 1 , 5]; +lb=[-.1, 2, 0.5,2 ]; + + options = optimoptions('fmincon', ... + 'Display', 'iter', ... + 'Algorithm', 'sqp', ... + 'OptimalityTolerance', 1e-7, ... + 'MaxFunctionEvaluations', 9000); + + problem = createOptimProblem('fmincon', 'x0', Xi, ... + 'objective', fun, ... + 'lb', lb, 'ub', ub, ... + 'options', options); + gs = GlobalSearch; + [Xr, fval, exitflag, output, manymins] = run(gs, problem); + +% A=ones(5); A(1,1)=0; A(3,3)=0; + +% [Xr,fval,exitflag,ou] = fmincon(fun,Xi,[],[],[],[],[-.05, 2, 0.5,2 ],[ 0.2, bound(2)+0.5, bound(3)+.1, bound(4)+0.5],[],options) ; +% [Xr,fval,exitflag] = fmincon(fun,Xi,[],[],[],[],[0.2, 2, 0.5,2 ],[ 0.4, bound(2)+.01, bound(3)+.01, bound(4)+.01],[],options) ; + + + +end diff --git a/gmproj/pressure/organize_data.ipynb b/gmproj/pressure/organize_data.ipynb new file mode 100644 index 0000000000..0bddfaf660 --- /dev/null +++ b/gmproj/pressure/organize_data.ipynb @@ -0,0 +1,484 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pybamm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import math\n", + "import dfols\n", + "import signal\n", + "from scipy.integrate import solve_ivp\n", + "from scipy.fft import fft, fftfreq, fftshift\n", + "from scipy.signal import savgol_filter\n", + "from scipy.signal import find_peaks\n", + "from scipy import interpolate, integrate\n", + "from stopit import threading_timeoutable as timeoutable\n", + "import os, sys\n", + "sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(\"__file__\"))))\n", + "from batfuns import *\n", + "plt.rcParams = set_rc_params(plt.rcParams)\n", + "import winsound\n", + "from pybamm import exp, constants, Parameter\n", + "import pickle\n", + "from tqdm import tqdm\n", + "\n", + "eSOH_DIR = \"../data/esoh_R/\"\n", + "oCV_DIR = \"../data/ocv/\"\n", + "cyc_DIR = \"../data/cycling/\"\n", + "fig_DIR = \"../figures/figures_model/\"\n", + "res_DIR = \"../data/results_paper/\"\n", + "resistance_DIR = \"../data/resistance/\"\n", + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_fun(data,n,cell_no):\n", + " df = data[data[\"Cycle number\"]==n]\n", + " df= df.reset_index(drop=True)\n", + " fig,ax = plt.subplots(2,2,figsize=(8,6))\n", + " ax1 = ax.flat[0]\n", + " ax1.plot(df[\"Time [s]\"],df[\"Voltage [V]\"])\n", + " ax1.set_ylabel(\"Voltage [V]\")\n", + " ax1.set_xlabel(\"Time [s]\")\n", + " ax2 = ax.flat[2]\n", + " ax2.plot(df[\"Time [s]\"],df[\"Current [mA]\"])\n", + " ax2.set_ylabel(\"Current [mA]\")\n", + " ax2.set_xlabel(\"Time [s]\")\n", + " ax3 = ax.flat[1]\n", + " ax3.plot(df[\"Time [s]\"],df[\"Expansion [mu m]\"])\n", + " ax3.set_ylabel(r\"Expansion [$\\mu$m]\")\n", + " ax3.set_xlabel(\"Time [s]\")\n", + " ax4 = ax.flat[3]\n", + " ax4.plot(df[\"Time [s]\"],df[\"Temperature [C]\"])\n", + " ax4.set_ylabel(r\"Temperature [$^\\circ$C]\")\n", + " ax4.set_xlabel(\"Time [s]\")\n", + " fig.suptitle(f\"Cell: {cell_no}, Cycle #{n}\")\n", + " fig.tight_layout()\n", + " return fig" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 151/151 [00:00<00:00, 358.87it/s]\n", + "100%|██████████| 31/31 [00:00<00:00, 553.73it/s]\n", + "100%|██████████| 169/169 [00:00<00:00, 192.13it/s]\n", + "100%|██████████| 151/151 [00:00<00:00, 449.93it/s]\n", + "100%|██████████| 170/170 [00:00<00:00, 235.28it/s]\n", + "100%|██████████| 181/181 [00:00<00:00, 212.09it/s]\n", + "100%|██████████| 221/221 [00:00<00:00, 313.60it/s]\n", + "100%|██████████| 181/181 [00:00<00:00, 293.23it/s]\n", + "100%|██████████| 61/61 [00:00<00:00, 281.34it/s]\n", + "100%|██████████| 221/221 [00:00<00:00, 370.83it/s]\n" + ] + } + ], + "source": [ + "for cell in range(26,36):\n", + " cell_no = f'{cell:02d}'\n", + " data = pd.read_csv(cyc_DIR+\"cycling_data_cell_\"+cell_no+\".csv\")\n", + " N1 = np.unique(data[\"Cycle number\"])\n", + " Ia = data[\"Current [mA]\"].to_numpy()/1000\n", + " ta = data[\"Time [s]\"].to_numpy()\n", + " AhTh = integrate.cumtrapz(abs(Ia), ta)/3600\n", + " AhTh = np.append(AhTh,AhTh[-1])\n", + " data[\"AhTh\"] = AhTh\n", + " Q_app = []\n", + " max_exp = []\n", + " min_exp = []\n", + " Rs = []\n", + " AhT = []\n", + " for n in tqdm(N1):\n", + " df = data[data[\"Cycle number\"]==n]\n", + " qmax = round(max(df[\"Capacity [Ah]\"]),2)\n", + " Q_app.append(qmax)\n", + " emax = round(max(df[\"Expansion [mu m]\"].fillna(0)),1)\n", + " max_exp.append(emax)\n", + " emin = round(min(df[\"Expansion [mu m]\"].fillna(0)),1)\n", + " min_exp.append(emin)\n", + " AhT.append(round(df[\"AhTh\"].iloc[0],1))\n", + " t = df[\"Time [s]\"].to_numpy()\n", + " V = df[\"Voltage [V]\"].to_numpy()\n", + " I = df[\"Current [mA]\"].to_numpy()/1000\n", + " try:\n", + " idxi1 = np.where((np.diff(I)<-1) & (I[:-1]>0))[0]\n", + " idx = idxi1[0]\n", + " R = (V[idx+1] - V[idx])/(I[idx+1] - I[idx])\n", + " Rs.append(round(R,5))\n", + " except:\n", + " Rs.append(np.NaN)\n", + " N = [n+1 for n in N1]\n", + " dfs = pd.DataFrame({\"N\":N,\"AhTh\":AhT,\"App Cap [Ah]\":Q_app,\"Min Exp [mu m]\":min_exp,\"Max Exp [mu m]\":max_exp,\"Rs [ohm]\":Rs})\n", + " mexp = round(dfs[\"Min Exp [mu m]\"].iloc[0],1)\n", + " dfs[\"Min Exp [mu m]\"] = dfs[\"Min Exp [mu m]\"] - mexp\n", + " dfs[\"Min Exp [mu m]\"] = dfs[\"Min Exp [mu m]\"].round(1)\n", + " dfs[\"Max Exp [mu m]\"] = dfs[\"Max Exp [mu m]\"] - mexp\n", + " dfs[\"Max Exp [mu m]\"] = dfs[\"Max Exp [mu m]\"].round(1)\n", + " dfs.to_csv(eSOH_DIR + \"aging_param_cell_cyc_\"+cell_no+\".csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig,ax = plt.subplots(1,1,figsize=(5,4))\n", + "ax.plot(N,Q_app,'o')\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(\"Apparent Capacity [Ah]\")\n", + "ax.set_title(\"Apparent Capacity 1 psi Cell\")\n", + "plt.savefig(fig_DIR + \"Apparent Cap.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig,ax = plt.subplots(1,1,figsize=(5,4))\n", + "ax.plot(N,min_exp,'o')\n", + "ax.plot(N,max_exp,'o')\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(r\"Expansion [$\\mu$m]\")\n", + "ax.set_title(\"Expansion 1 psi Cell\")\n", + "ax.legend([\"Min\",\"Max\"])\n", + "plt.savefig(fig_DIR + \"Expansion.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig,ax = plt.subplots(1,1,figsize=(5,4))\n", + "# ax.plot(data[\"Time [s]\"],data[\"Capacity [Ah]\"])\n", + "ax.plot(data[\"Time [s]\"],data[\"Q [Ah]\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "df= df.reset_index(drop=True)\n", + "fig,ax = plt.subplots(2,1,figsize=(4,6))\n", + "ax1 = ax.flat[0]\n", + "ax1.plot(t,V)\n", + "ax1.plot(t[idx],V[idx],\"rx\")\n", + "ax1.plot(t[idx+1],V[idx+1],\"rx\")\n", + "ax1.set_ylabel(\"Voltage [V]\")\n", + "ax1.set_xlabel(\"Time [s]\")\n", + "ax2 = ax.flat[1]\n", + "ax2.plot(t,I)\n", + "ax2.plot(t[idx],I[idx],\"rx\")\n", + "ax2.plot(t[idx+1],I[idx+1],\"rx\")\n", + "ax2.set_ylabel(\"Current [A]\")\n", + "ax2.set_xlabel(\"Time [s]\")\n", + "fig.suptitle(f\"Cell: {cell_no}, Cycle #{n}\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n = N1[0]\n", + "fig = plot_fun(data,n,cell_no)\n", + "plt.savefig(fig_DIR + \"cycle 0.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Aging Metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f878c54285c84a47878d37bd9a32be66", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1,figsize=(5,4))\n", + "for cell in range(26,36):\n", + " cell_no = f'{cell:02d}'\n", + " df1 = pd.read_csv(eSOH_DIR + \"aging_param_cell_\" + cell_no + \".csv\")\n", + " ax.plot(df1[\"N\"],df1[\"App Cap [Ah]\"])\n", + "ax.legend([\"1 PSI\",\"5 PSI\",\"5 PSI\",\"10 PSI\",\"10 PSI\",\"15 PSI\",\"15 PSI\",\"20 PSI\",\"20 PSI\",\"25 PSI\"])\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(\"Apparent Capacity [Ah]\")\n", + "ax.set_title(\"Apparent Capacity\")\n", + "plt.savefig(fig_DIR + \"Apparent Cap All.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1,1,figsize=(5,4))\n", + "for cell in range(26,36):\n", + " cell_no = f'{cell:02d}'\n", + " df1 = pd.read_csv(eSOH_DIR + \"aging_param_cell_\" + cell_no + \".csv\")\n", + " ax.plot(df1[\"N\"],df1[\"Min Exp [mu m]\"])\n", + "ax.legend([\"1 PSI\",\"5 PSI\",\"5 PSI\",\"10 PSI\",\"10 PSI\",\"15 PSI\",\"15 PSI\",\"20 PSI\",\"20 PSI\",\"25 PSI\"])\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(r\"Irreversible Expansion [$\\mu$m]\")\n", + "ax.set_title(\"Irreversible Expansion\")\n", + "plt.savefig(fig_DIR + \"Expansion All.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df1.columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1,1,figsize=(5,4))\n", + "for cell in range(26,36):\n", + " cell_no = f'{cell:02d}'\n", + " df1 = pd.read_csv(eSOH_DIR + \"aging_param_cell_\" + cell_no + \".csv\")\n", + " ax.plot(df1[\"N\"],df1[\"Rs [ohm]\"])\n", + "ax.legend([\"1 PSI\",\"5 PSI\",\"5 PSI\",\"10 PSI\",\"10 PSI\",\"15 PSI\",\"15 PSI\",\"20 PSI\",\"20 PSI\",\"25 PSI\"])\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(r\"Resistance [$\\Omega$]\")\n", + "ax.set_title(\"Resistance\")\n", + "plt.savefig(fig_DIR + \"Resistance All.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "cells = [1,4,7,10]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0, 5.0)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf54e49d278243d2a0ed310b66b68fdb", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1,figsize=(5,4))\n", + "for cell in cells:\n", + " cell_no = f'{cell:02d}'\n", + " df1 = pd.read_csv(eSOH_DIR + \"aging_param_cell_cyc_\" + cell_no + \".csv\")\n", + " ax.plot(df1[\"N\"],df1[\"App Cap [Ah]\"])\n", + "ax.legend([\"C/5\",\"1.5C\",\"2C\",\"Mixed Crate\"])\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(\"Apparent Capacity [Ah]\")\n", + "ax.set_title(\"Apparent Capacity\")\n", + "ax.set_ylim(1,5)\n", + "# plt.savefig(fig_DIR + \"Apparent Cap All.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "733972bf6c424ea79fb60ada9a3e8725", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1,figsize=(5,4))\n", + "for cell in cells:\n", + " cell_no = f'{cell:02d}'\n", + " df1 = pd.read_csv(eSOH_DIR + \"aging_param_cell_cyc_\" + cell_no + \".csv\")\n", + " ax.plot(df1[\"N\"],df1[\"Min Exp [mu m]\"])\n", + "ax.legend([\"C/5\",\"1.5C\",\"2C\",\"Mixed Crate\"])\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(r\"Irreversible Expansion [$\\mu$m]\")\n", + "ax.set_title(\"Irreversible Expansion\")\n", + "plt.savefig(fig_DIR + \"Expansion All.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4a97ab7b961d4ed191bd56c71c74abed", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1,figsize=(5,4))\n", + "for cell in cells:\n", + " cell_no = f'{cell:02d}'\n", + " df1 = pd.read_csv(eSOH_DIR + \"aging_param_cell_cyc_\" + cell_no + \".csv\")\n", + " ax.plot(df1[\"N\"],df1[\"Rs [ohm]\"])\n", + "ax.legend([\"C/5\",\"1.5C\",\"2C\",\"Mixed Crate\"])\n", + "ax.set_xlabel(\"Cycle Number\")\n", + "ax.set_ylabel(r\"Resistance [$\\Omega$]\")\n", + "ax.set_title(\"Resistance\")\n", + "plt.savefig(fig_DIR + \"Resistance All.png\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "windows-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}