import pandas as pd
import numpy as np
import datetime
import bisect
import matplotlib.pyplot as plt
import BatParam
class BatSoh:
def __init__(self,sn,celltype,df_bms,df_volt,df_temp,df_accum): #参数初始化
self.sn=sn
self.celltype=celltype
CellVoltNums=int(df_volt.loc[5,'单体电池总数'])
if CellVoltNums==110:
self.celltype=99
else:
self.celltype==100
self.param=BatParam.BatParam(self.celltype)
self.df_volt=df_volt
self.df_temp=df_temp
self.bmsstat=df_bms['充电状态']
self.packcrnt=(df_volt['可充电储能装置电流(A)'].astype('float'))*self.param.PackCrntDec
self.packvolt=df_volt['可充电储能装置电压(V)'].astype('float')
self.bms_soc=df_bms['SOC']
# self.bms_soh=df_volt['SOH[%]']
self.bmstime= pd.to_datetime(df_volt['上报时间'], format='%Y-%m-%d %H:%M:%S')
self.param.CellVoltNums=CellVoltNums
self.param.CellTempNums=int(df_temp.loc[5,'可充电储能温度探针个数'])
def batsoh(self):
if self.celltype==1 or self.celltype==2 or self.celltype==3 or self.celltype==4 or self.celltype==100:
df_res=self._ncmsoh_chrg()
return df_res
elif self.celltype==99:
df_res=self._lfpsoh()
return df_res
else:
return pd.DataFrame()
#定义滑动滤波函数.........................................................................................................................
def _np_move_avg(self,a, n, mode="same"):
return (np.convolve(a, np.ones((n,)) / n, mode=mode))
#寻找当前行数据的最小温度值.................................................................................................................
def _celltemp_weight(self,num):
celltemp = []
for j in range(1, self.param.CellTempNums+1):
s = str(j)
celltemp.append(self.df_temp.loc[num, s+'.0'])
celltemp.remove(min(celltemp))
self.celltemp=celltemp
if self.celltype==99:
if min(celltemp)>=20:
self.tempweight=1
self.StandardStandingTime=1800
elif min(celltemp)>=10:
self.tempweight=0.5
self.StandardStandingTime=3600
elif min(celltemp)>=5:
self.tempweight=0
self.StandardStandingTime=7200
else:
self.tempweight=0
self.StandardStandingTime=10800
else:
if min(celltemp)>=20:
self.tempweight=1
self.StandardStandingTime=1800
elif min(celltemp)>=10:
self.tempweight=0.8
self.StandardStandingTime=3600
elif min(celltemp)>=5:
self.tempweight=0.3
self.StandardStandingTime=3600
else:
self.tempweight=0.1
self.StandardStandingTime=7200
#获取SOC差对应的SOH权重值...................................................................................................................
def _deltsoc_weight(self,deltsoc):
if deltsoc>60:
deltsoc_weight=1
elif deltsoc>50:
deltsoc_weight=0.9
elif deltsoc>40:
deltsoc_weight=0.7
elif deltsoc>30:
deltsoc_weight=0.5
elif deltsoc>20:
deltsoc_weight=0.3
else:
deltsoc_weight=0
return deltsoc_weight
#获取当前行所有电压数据......................................................................................................................
def _cellvolt_get(self,num):
cellvolt=[]
for j in range(1, self.param.CellVoltNums+1):
s = str(j)
cellvolt.append(self.df_volt.loc[num, s+'.0'])
return cellvolt
#筛选充电数据..............................................................................................................................
def _chrgdata(self):
self.ChgStart=[]
self.ChgEnd=[]
if len(self.packvolt)>100:
charging=0
for i in range(3, len(self.bmstime) - 3):
if charging==0:
if i==3 and self.bmsstat[i]=='停车充电' and self.bmsstat[i+1]=='停车充电':
self.ChgStart.append(i)
charging=1
elif self.bmsstat[i-1]!='停车充电' and self.bmsstat[i]=='停车充电':
self.ChgStart.append(i)
charging=1
else:
pass
else:
if (self.bmsstat[i-1]=='停车充电' or '充电完成') and self.packcrnt[i]>0:
self.ChgEnd.append(i)
charging=0
elif i == (len(self.bmstime) - 4) and (self.bmsstat[i] == '停车充电' or '充电完成') and self.packcrnt[i]<-1:
self.ChgEnd.append(len(self.bmstime)-2)
charging=0
#dvdq方法计算soh...........................................................................................................................
def _dvdq_soh(self, chrg_st, chrg_end,cellvolt):
Ah = 0 #参数赋初始值
Volt = cellvolt[chrg_st]
DV_Volt=[]
DQ_Ah = []
DVDQ = []
time2 = []
soc2 = []
Ah_tatal=[0]
xvolt=[]
#计算DV和DQ值
for j in range(chrg_st,chrg_end):
Step=(self.bmstime[j+1]-self.bmstime[j]).total_seconds()
Ah=Ah-self.packcrnt[j]*Step/3600
if (cellvolt[j]-Volt)>0.0019 and Ah>0:
Ah_tatal.append(Ah_tatal[-1]+Ah)
DQ_Ah.append(Ah)
DV_Volt.append(cellvolt[j]-Volt)
DVDQ.append((DV_Volt[-1])/DQ_Ah[-1])
xvolt.append(cellvolt[j])
Volt=cellvolt[j]
Ah = 0
time2.append(self.bmstime[j])
soc2.append(float(self.bms_soc[j].strip('%')))
#切片，去除前后10min的数据
df_Data1 = pd.DataFrame({'time': time2,
'SOC': soc2,
'DVDQ': DVDQ,
'Ah_tatal': Ah_tatal[:-1],
'DQ_Ah':DQ_Ah,
'DV_Volt':DV_Volt,
'XVOLT':xvolt})
start_time=df_Data1.loc[0,'time']
start_time=start_time+datetime.timedelta(seconds=900)
end_time=df_Data1.loc[len(time2)-1,'time']
end_time=end_time-datetime.timedelta(seconds=1200)
if soc2[0]<36:
df_Data1=df_Data1[(df_Data1['SOC']>40) & (df_Data1['SOC']<80)]
else:
df_Data1=df_Data1[(df_Data1['time']>start_time) & (df_Data1['SOC']<80)]
df_Data1=df_Data1[(df_Data1['XVOLT']>self.param.PeakVoltLowLmt) & (df_Data1['XVOLT']<self.param.PeakVoltUpLmt)]
# self._celltemp_weight(int((chrg_st+chrg_end)/2))
# print(self.packcrnt[int((chrg_st+chrg_end)/2)], min(self.celltemp))
# ax1 = plt.subplot(3, 1, 1)
# plt.plot(df_Data1['XVOLT'],df_Data1['DVDQ'],'r*-')
# plt.xlabel('Volt/V')
# plt.ylabel('DV/DQ')
# plt.legend()
# ax1 = plt.subplot(3, 1, 2)
# plt.plot(df_Data1['SOC'],df_Data1['XVOLT'],'y*-')
# plt.xlabel('SOC/%')
# plt.ylabel('Volt/V')
# plt.legend()
# ax1 = plt.subplot(3, 1, 3)
# plt.plot(df_Data1['SOC'], df_Data1['DVDQ'], 'r*-')
# plt.xlabel('SOC/%')
# plt.ylabel('DV/DQ')
# plt.legend()
# plt.show()
#寻找峰值并计算Soh
if len(df_Data1)>1:
PeakIndex=df_Data1['DVDQ'].idxmax()
#筛选峰值点附近±0.5%SOC内的数据
df_Data2=df_Data1[(df_Data1['SOC']>(df_Data1['SOC'][PeakIndex]-0.5)) & (df_Data1['SOC']<(df_Data1['SOC'][PeakIndex]+0.5))]
if len(df_Data2)>1 and df_Data1.loc[PeakIndex,'XVOLT']<self.param.PeakVoltUpLmt-0.019:
Ah_tatal1 = df_Data1['Ah_tatal']
DVDQ = df_Data1['DVDQ']
soc2 = df_Data1['SOC']
xvolt = df_Data1['XVOLT']
if soc2[PeakIndex]>40 and soc2[PeakIndex]<80:
cellsoh_init=(Ah_tatal[-1]-Ah_tatal1[PeakIndex]) * 100 / ((self.param.FullChrgSoc - self.param.PeakSoc) * 0.01 * self.param.Capacity)
if cellsoh_init<95:
cellsoh_init=cellsoh_init*0.3926+58.14
return cellsoh_init
else:
return cellsoh_init
else:
return 0
else:
df_Data1=df_Data1.drop([PeakIndex])
PeakIndex = df_Data1['DVDQ'].idxmax()
df_Data2 = df_Data1[(df_Data1['SOC'] > (df_Data1['SOC'][PeakIndex] - 0.5)) & (df_Data1['SOC'] < (df_Data1['SOC'][PeakIndex] + 0.5))]
if len(df_Data2) > 1 and df_Data1.loc[PeakIndex,'XVOLT']<self.param.PeakVoltUpLmt-0.019:
Ah_tatal1 = df_Data1['Ah_tatal']
DVDQ = df_Data1['DVDQ']
soc2 = df_Data1['SOC']
xvolt = df_Data1['XVOLT']
if soc2[PeakIndex]>40 and soc2[PeakIndex]<80:
cellsoh_init=(Ah_tatal[-1]-Ah_tatal1[PeakIndex]) * 100 / ((self.param.FullChrgSoc - self.param.PeakSoc) * 0.01 * self.param.Capacity)
if cellsoh_init<95:
cellsoh_init=cellsoh_init*0.3926+58.14
return cellsoh_init
else:
return cellsoh_init
else:
return 0
else:
return 0
else:
return 0
#两点法计算三元SOH.........................................................................................................................
def _ncmsoh_twopoint(self):
standingpoint_st=[]
standingpoint_sp=[]
tempweightlist=[]
standingtime=0
for i in range(3,len(self.df_volt)-3):
if abs(self.packcrnt[i]) < 0.2 and abs(self.packcrnt[i-1]) < 0.2 and abs(self.packcrnt[i+1]) < 0.2: #电流为0
delttime=(self.bmstime[i]-self.bmstime[i-1]).total_seconds()
standingtime=standingtime+delttime
self._celltemp_weight(i) #获取不同温度对应的静置时间
if standingtime>self.StandardStandingTime: #静置时间满足要求
if standingpoint_st:
if len(standingpoint_st)>len(standingpoint_sp): #开始时刻已获取，结束时刻未获取
cellvolt_now=self._cellvolt_get(i) #获取当前行电压数据
minocv_socnow=np.interp(min(cellvolt_now),self.param.LookTab_OCV,self.param.LookTab_SOC)
cellvolt_st=self._cellvolt_get(standingpoint_st[-1]) #获取开始时刻静置后的电压数据
minocv_socst=np.interp(min(cellvolt_st),self.param.LookTab_OCV,self.param.LookTab_SOC)
if 3<max(cellvolt_now)<4.5 and 3<min(cellvolt_now)<4.5:
if abs(minocv_socst-minocv_socnow)>=30: #当前时刻SOC与开始时刻SOC差>=40
if abs(self.packcrnt[i+2])>=0.2: #如果下一时刻电流>=0.5，则压入当前索引
standingpoint_sp.append(i)
standingpoint_st.append(i)
tempweightlist.append(self.tempweight)
standingtime=0
continue
else:
if standingtime>7200 or i==len(self.df_volt)-2: #仍处于静置，但静置时间>1h，则直接获取sp时刻，或者到了数据末尾
standingpoint_sp.append(i)
tempweightlist.append(self.tempweight)
continue
else:
if abs(self.packcrnt[i+2])>=0.2:
standingtime=0
if minocv_socst<50 and minocv_socnow<minocv_socst:
standingpoint_st[-1]=i
continue
elif abs(self.packcrnt[i+2])>=0.2:
standingtime=0
if minocv_socst>=50 and minocv_socnow>minocv_socst:
standingpoint_st[-1]=i
continue
else:
continue
else:
if abs(self.packcrnt[i+2])>=0.5:
cellvolt_now=self._cellvolt_get(i)
if 3<max(cellvolt_now)<4.5 and 3<min(cellvolt_now)<4.5:
standingpoint_st.append(i)
standingtime=0
continue
else:
continue
else:
if abs(self.packcrnt[i+2])>0.5:
cellvolt_now=self._cellvolt_get(i)
if 3<max(cellvolt_now)<4.5 and 3<min(cellvolt_now)<4.5:
standingpoint_st.append(i)
standingtime=0
continue
else:
continue
else:
continue
else:
standingtime=0
continue
#计算SOH......................................................................................................................
if standingpoint_sp:
column_name=['time_st','time_sp','sn','method','soh','cellsoh','detasoh']
df_res=pd.DataFrame(columns=column_name)
for i in range(len(standingpoint_sp)):
cellocv_st=self._cellvolt_get(standingpoint_st[i]) #获取静置点所有电芯的电压
cellocv_sp=self._cellvolt_get(standingpoint_sp[i])
# accumtime=self.accumtime.to_list() #累计量的时间列表
timepoint_bms_st=self.bmstime[standingpoint_st[i]] #获取静置点的时间
timepoint_bms_sp=self.bmstime[standingpoint_sp[i]]
# timepoint_accum_st=bisect.bisect(accumtime,timepoint_bms_st) #获取最接近静置点时间的累计量时间点
# timepoint_accum_sp=bisect.bisect(accumtime,timepoint_bms_sp)
# if timepoint_accum_sp>=len(accumtime): #防止指针超出数据范围
# timepoint_accum_sp=len(accumtime)-1
ah_packcrnt_dis=0
ah_packcrnt_chg=0
for j in range(standingpoint_st[i]+2,standingpoint_sp[i]): #计算累计Ah
Step=(self.bmstime[j+1]-self.bmstime[j]).total_seconds()
if Step<60:
if self.packcrnt[j+1]>=0:
ah_packcrnt_dis=ah_packcrnt_dis+self.packcrnt[j+1]*Step
else:
ah_packcrnt_chg=ah_packcrnt_chg-self.packcrnt[j+1]*Step
ah_packcrnt_chg=ah_packcrnt_chg/3600
ah_packcrnt_dis=ah_packcrnt_dis/3600
ah_packcrnt=ah_packcrnt_chg-ah_packcrnt_dis #两个静置点的总累计AH，负值代表放电，正值代表充电
# ah_accum_dis=self.df_accum.loc[timepoint_accum_sp,'累计放电电量']-self.df_accum.loc[timepoint_accum_st,'累计放电电量'] #两个静置点之间的放电电量
# ah_accum_chg=self.df_accum.loc[timepoint_accum_sp,'累计充电电量']-self.df_accum.loc[timepoint_accum_st,'累计充电电量'] #两个静置点之间的充电电量
# ah_accum_tatol=ah_accum_chg-ah_accum_dis #两个静置点的总累计AH，负值代表放电，正值代表充电
ah_accum=ah_packcrnt
# delt_days=(self.bmstime[standingpoint_sp[i]]-self.bmstime[standingpoint_st[i]]).total_seconds()/(3600*24)
# if delt_days<=1: #两次时间间隔对计算结果的影响
# soh_weight1=1
# elif delt_days<=2:
# soh_weight1=0.7
# elif delt_days<=3:
# soh_weight1=0.4
# else:
# soh_weight1=0
# if ah_packcrnt_dis<self.param.Capacity: #放电ah数对结果的影响
# soh_weight1=(1-ah_packcrnt_dis/(self.param.Capacity*1.5))*soh_weight1
# else:
# soh_weight1=0.1
# if self.param.Capacity**0.7*0.4 < abs(ah_accum_tatol) < self.param.Capacity: #累计量的权重
# if abs(ah_accum_tatol-ah_packcrnt)<self.param.Capacity/20:
# soh_weight1=soh_weight1*1
# elif abs(ah_accum_tatol-ah_packcrnt) < self.param.Capacity/10:
# soh_weight1=soh_weight1*0.8
# else:
# soh_weight1=soh_weight1*0.5
# else:
# if self.param.Capacity*0.7*0.4< abs(ah_packcrnt) <self.param.Capacity:
# soh_weight1=soh_weight1*0.3
# else:
# soh_weight1=0
cellsoh=[]
for j in range(self.param.CellVoltNums): #计算每个电芯的SOH值
ocv_soc1=np.interp(cellocv_st[j],self.param.LookTab_OCV,self.param.LookTab_SOC)
ocv_soc2=np.interp(cellocv_sp[j],self.param.LookTab_OCV,self.param.LookTab_SOC)
# delt_ocv_soc=ocv_soc2-ocv_soc1
# delt_ocv_soc_weight=self._deltsoc_weight(abs(delt_ocv_soc))
# soh_weight=soh_weight1*tempweightlist[i]*delt_ocv_soc_weight*0.5
cellsoh_init=ah_accum*100/((ocv_soc2-ocv_soc1)*0.01*self.param.Capacity)
# if cellsoh_init>55 and cellsoh_init<120: #判断soh值的有效区间
# if len(df_res)<1:
# if not self.df_soh.empty and 55<self.df_soh.loc[len(self.df_soh)-1,'soh']<120:
# cellsoh_last=eval(self.df_soh.loc[len(self.df_soh)-1,'cellsoh'])
# if soh_weight>1/abs(cellsoh_init-cellsoh_last[j]):
# soh_weight=1/abs(cellsoh_init-cellsoh_last[j])
# cellsoh_cal=cellsoh_init*soh_weight + cellsoh_last[j]*(1-soh_weight)
# else:
# cellsoh_cal=cellsoh_init*soh_weight + cellsoh_last[j]*(1-soh_weight)
# else:
# cellsoh_cal=cellsoh_init*soh_weight+100*(1-soh_weight)
# else:
# cellsoh_last=eval(df_res.loc[len(df_res)-1,'cellsoh'])
# if soh_weight>1/abs(cellsoh_init-cellsoh_last[j]):
# soh_weight=1/abs(cellsoh_init-cellsoh_last[j])
# cellsoh_cal=cellsoh_init*soh_weight + cellsoh_last[j]*(1-soh_weight)
# else:
# cellsoh_cal=cellsoh_init*soh_weight + cellsoh_last[j]*(1-soh_weight)
# cellsoh_cal=eval(format(cellsoh_cal,'.1f'))
cellsoh.append(cellsoh_init)
# else:
# cellsoh=[]
# break
if cellsoh:
soh=min(cellsoh)
soh_list=[timepoint_bms_st, timepoint_bms_sp, self.sn, 1, soh, str(cellsoh),max(cellsoh)-min(cellsoh)]
df_res.loc[len(df_res)]=soh_list
else:
continue
if df_res.empty:
return pd.DataFrame()
else:
return df_res
return pd.DataFrame()
def _ncmsoh_chrg(self):
self._chrgdata()
print(self.ChgStart,self.ChgEnd)
ChgStartValid=[]
ChgEndValid=[]
for i in range(min(len(self.ChgStart),len(self.ChgEnd))):
self._celltemp_weight(self.ChgEnd[i]) #获取温度对应的静置时间及权重
#筛选满足2点法计算的数据
StandingTime=0
StandingTime1=0
for m in range(max(len(self.packcrnt)-self.ChgEnd[i]-2,self.ChgStart[i]-2)):
if self.ChgStart[i] - m - 1>0 and abs(self.packcrnt[self.ChgStart[i] - m - 1]) < 0.5:
StandingTime = StandingTime + (self.bmstime[self.ChgStart[i] - m] - self.bmstime[self.ChgStart[i] - m - 1]).total_seconds()
if self.ChgEnd[i] + m + 1<len(self.packcrnt) and abs(self.packcrnt[self.ChgEnd[i] + m + 1]) < 0.5:
StandingTime1 = StandingTime1 + (self.bmstime[self.ChgEnd[i] + m + 1] - self.bmstime[self.ChgEnd[i] + m]).total_seconds()
if StandingTime > self.StandardStandingTime and StandingTime1>self.StandardStandingTime: #筛选静置时间>15min且慢充过程丢失数据少
ChgStartValid.append(self.ChgStart[i])
ChgEndValid.append(self.ChgEnd[i]+m)
break
if abs(self.packcrnt[self.ChgStart[i] - m - 2])>0.5 and abs(self.packcrnt[self.ChgEnd[i] + m + 2])>0.5:
StandingTime=0
StandingTime1=0
break
print(ChgStartValid,ChgEndValid)
if len(ChgStartValid)>0: #两点法计算Soh
df_res=pd.DataFrame(columns=('time','sn','soh','cellsoh','deltsoh'))
soh2=[]
for i in range(len(ChgStartValid)):
Ah=0
for j in range(ChgStartValid[i],ChgEndValid[i]): #计算Ah
Step=(self.bmstime[j+1]-self.bmstime[j]).total_seconds()
if Step<120:
Ah=Ah-self.packcrnt[j+1]*Step/3600
if Ah>10:
for j in range(1, self.param.CellVoltNums+1): #计算每个电芯的Soh
s = str(j)
OCVStart=self.df_volt.loc[ChgStartValid[i]-1,s+'.0']
OCVEnd=self.df_volt.loc[ChgEndValid[i],s+'.0']
#soh
ocv_Soc1=np.interp(OCVStart,self.param.LookTab_OCV,self.param.LookTab_SOC)
ocv_Soc2=np.interp(OCVEnd,self.param.LookTab_OCV,self.param.LookTab_SOC)
soh2.append(Ah*100/((ocv_Soc2-ocv_Soc1)*0.01*self.param.Capacity))
soh1=np.mean(soh2)
delasoh=max(soh2)-min(soh2)
df_res.loc[len(df_res)]=[self.bmstime[ChgStartValid[i]],self.sn,soh1,soh2,delasoh]
return df_res
return pd.DataFrame()
#两点法和DVDQ法计算磷酸铁锂电池SOH..................................................................................................................
def _lfpsoh(self):
standingpoint_st=[]
standingpoint_sp=[]
tempweightlist1=[]
cellmaxvolt_number1=[]
standingtime=0
chrg_start=[]
chrg_end=[]
tempweightlist2=[]
cellmaxvolt_number2=[]
charging=0
for i in range(3,len(self.df_volt)-3):
#获取两点法法所需数据-开始.................................................................................................................
if abs(self.packcrnt[i]) < 0.1 and abs(self.packcrnt[i-1]) < 0.1 and abs(self.packcrnt[i+1]) < 0.1: #判断非平台区静置状态
delttime=(self.bmstime[i]-self.bmstime[i-1]).total_seconds()
standingtime=standingtime+delttime
self._celltemp_weight(i) #获取不同温度对应的静置时间
if standingtime>self.StandardStandingTime: #静置时间满足要求
if abs(self.packcrnt[i+2])>=0.1: #下一时刻电流>0.1A
standingtime=0
cellvolt_now=self._cellvolt_get(i)
if max(cellvolt_now)<self.param.OcvInflexionBelow: #当前最大电芯电压<OCV下拐点
if standingpoint_st:
if len(standingpoint_st)>len(standingpoint_sp):
if self.packcrnt[standingpoint_st[-1]]<-1: #判断上一次静置点的是否为满充
standingpoint_sp.append(i)
standingpoint_st.append(i)
tempweightlist1.append(self.tempweight)
else:
standingpoint_st[-1]=i
tempweightlist1[-1]=self.tempweight
else:
standingpoint_st.append(i)
tempweightlist1.append(self.tempweight)
else:
standingpoint_st.append(i)
tempweightlist1.append(self.tempweight)
else:
pass
else:
pass
else:
pass
elif self.packcrnt[i]<=-1 and self.packcrnt[i-1]<=-1 and self.packcrnt[i+1]<=-1 and self.packcrnt[i+2]>-1: #判读满充状态
standingtime=0
self._celltemp_weight(i)
cellvolt_now=self._cellvolt_get(i)
if max(cellvolt_now)>self.param.CellFullChrgVolt:
if standingpoint_st:
if len(standingpoint_st)>len(standingpoint_sp):
if abs(self.packcrnt[standingpoint_st[-1]])<0.5: #判断上一次静置点是否为下拐点
standingpoint_sp.append(i)
standingpoint_st.append(i)
tempweightlist1.append(self.tempweight)
cellmaxvolt_number1.append(cellvolt_now.index(max(cellvolt_now))) #获取最大电压索引
cellmaxvolt_number1.append(cellvolt_now.index(max(cellvolt_now))) #获取最大电压索引
else:
standingpoint_st[-1]=i
tempweightlist1[-1]=self.tempweight
cellmaxvolt_number1[-1]=cellvolt_now.index(max(cellvolt_now))
else:
standingpoint_st.append(i)
tempweightlist1.append(self.tempweight)
cellmaxvolt_number1.append(cellvolt_now.index(max(cellvolt_now)))
else:
pass
else:
standingtime=0
pass
#获取DVDQ算法所需数据——开始.............................................................................................................
if charging==0:
if self.packcrnt[i]<=-1 and self.packcrnt[i+1]<=-1 and self.packcrnt[i+2]<=-1 and float(self.bms_soc[i].strip('%'))<40: #充电开始
self._celltemp_weight(i)
charging=1
if len(chrg_start)>len(chrg_end):
chrg_start[-1]=i
tempweightlist2[-1]=self.tempweight
else:
chrg_start.append(i)
tempweightlist2.append(self.tempweight)
else:
pass
else: #充电中
if (self.bmstime[i+1]-self.bmstime[i]).total_seconds()>180 or (self.packcrnt[i]>self.param.Capacity/3 and self.packcrnt[i+1]>self.param.Capacity/3): #如果充电过程中时间间隔>180s，或者电流过大，则舍弃该次充电
chrg_start.remove(chrg_start[-1])
tempweightlist2.remove(tempweightlist2[-1])
charging=0
continue
elif self.packcrnt[i]<=-1 and self.packcrnt[i+1]<=-1 and self.packcrnt[i+2]>-1: #判断电流波动时刻
cellvolt_now=self._cellvolt_get(i+1)
if max(cellvolt_now)>self.param.CellFullChrgVolt: #电压>满充电压
chrg_end.append(i+1)
cellmaxvolt_number2.append(cellvolt_now.index(max(cellvolt_now))) #获取最大电压索引
charging=0
continue
else:
pass
elif self.packcrnt[i+1]>-0.1 and self.packcrnt[i+2]>-0.1: #判断充电结束
charging=0
if len(chrg_start)>len(chrg_end):
chrg_start.remove(chrg_start[-1])
tempweightlist2.remove(tempweightlist2[-1])
continue
else:
continue
elif i==len(self.packcrnt)-4 and self.packcrnt[i+1]<-1 and self.packcrnt[i+2]<-1:
charging=0
if len(chrg_start)>len(chrg_end):
cellvolt_now=self._cellvolt_get(i)
if max(cellvolt_now)>self.param.CellFullChrgVolt: #电压>满充电压
chrg_end.append(i)
cellmaxvolt_number2.append(cellvolt_now.index(max(cellvolt_now))) #获取最大电压索引
continue
else:
chrg_start.remove(chrg_start[-1])
tempweightlist2.remove(tempweightlist2[-1])
continue
else:
continue
else:
continue
#开始计算SOH.............................................................................................................................................
if standingpoint_sp or chrg_end:
# self.getdata() #获取已计算的soh
column_name=['time_st','time_sp','sn','method','soh','cellsoh']
df_res=pd.DataFrame(columns=column_name)
#两点法计算SOH........................................................................................................................................
if standingpoint_sp:
for i in range(len(standingpoint_sp)): #判断为满充点或者下拐点
if self.packcrnt[standingpoint_sp[i]]<=-1:
cellocv_st=self._cellvolt_get(standingpoint_st[i])
ocv_soc1=np.interp(cellocv_st[cellmaxvolt_number1[i]],self.param.LookTab_OCV,self.param.LookTab_SOC)
ocv_soc2=self.param.FullChrgSoc
else:
cellocv_sp=self._cellvolt_get(standingpoint_sp[i])
ocv_soc1=self.param.FullChrgSoc
ocv_soc2=np.interp(cellocv_sp[cellmaxvolt_number1[i]],self.param.LookTab_OCV,self.param.LookTab_SOC)
# cellocv_sp=self._cellvolt_get(standingpoint_sp[i])
# accumtime=self.accumtime.to_list() #累计量的时间列表
timepoint_bms_st=self.bmstime[standingpoint_st[i]] #获取静置点的时间
timepoint_bms_sp=self.bmstime[standingpoint_sp[i]]
# timepoint_accum_st=bisect.bisect(accumtime,timepoint_bms_st) #获取最接近静置点时间的累计量时间点
# timepoint_accum_sp=bisect.bisect(accumtime,timepoint_bms_sp)
# if timepoint_accum_sp>=len(accumtime): #防止指针超出数据范围
# timepoint_accum_sp=len(accumtime)-1
ah_packcrnt_dis=0
ah_packcrnt_chg=0
for j in range(standingpoint_st[i]+2,standingpoint_sp[i]+1): #计算累计Ah
Step=(self.bmstime[j+1]-self.bmstime[j]).total_seconds()
if Step<60:
if self.packcrnt[j+1]>=0:
ah_packcrnt_dis=ah_packcrnt_dis+self.packcrnt[j+1]*Step
else:
ah_packcrnt_chg=ah_packcrnt_chg-self.packcrnt[j+1]*Step
ah_packcrnt_chg=ah_packcrnt_chg/3600
ah_packcrnt_dis=ah_packcrnt_dis/3600
ah_packcrnt=ah_packcrnt_chg-ah_packcrnt_dis #两个静置点的总累计AH，负值代表放电，正值代表充电
ah_accum=ah_packcrnt
# delt_ocv_soc=ocv_soc2-ocv_soc1
# delt_ocv_soc_weight=self._deltsoc_weight(abs(delt_ocv_soc))
# soh_weight=soh_weight*tempweightlist1[i]*delt_ocv_soc_weight*0.5
cellsoh_init=ah_accum*100/((ocv_soc2-ocv_soc1)*0.01*self.param.Capacity)
if cellsoh_init>60 and cellsoh_init<115: #判断soh值的有效区间
soh_list=[timepoint_bms_st, timepoint_bms_sp, self.sn, 1, cellsoh_init, cellsoh_init]
df_res.loc[len(df_res)]=soh_list
else:
pass
else:
pass
#DVDQ法计算SOH.......................................................................................................................................
if chrg_end:
for i in range(len(chrg_end)):
cellvolt_max = self.df_volt[ str(cellmaxvolt_number2[i]+1)+'.0'] #获取最大电压
cellvolt=self._np_move_avg(cellvolt_max, 3, mode="same") #对电压进行滑动平均滤
cellsoh_init=self._dvdq_soh(chrg_start[i],chrg_end[i],cellvolt) #dvdq计算soh
soh_weight=tempweightlist2[i]*0.25
if cellsoh_init>60 and cellsoh_init<115: #判断soh值的有效区间
soh_list=[self.bmstime[chrg_start[i]], self.bmstime[chrg_end[i]], self.sn, 2, cellsoh_init, str(cellsoh_init),soh_weight]
df_res.loc[len(df_res)]=soh_list
else:
pass
#对SOH结果进行滤波处理................................................................................................................................
return df_res
return pd.DataFrame()