import pandas as pd
import numpy as np
import datetime
import BatParam

class BatUniform():
    def __init__(self,sn,celltype,df_bms,df_uniform,df_last3,df_lfp1):  #参数初始化

        if (not df_lfp1.empty) and celltype>50:
            df_bms=pd.concat([df_lfp1, df_bms], ignore_index=True)
            df_bms.reset_index(inplace=True,drop=True)
        else:
            pass

        self.sn=sn
        self.celltype=celltype
        self.param=BatParam.BatParam(celltype)
        self.df_bms=df_bms
        self.packcrnt=df_bms['PackCrnt']*self.param.PackCrntDec
        self.packvolt=df_bms['PackVolt']
        self.bms_soc=df_bms['PackSOC']
        self.bmstime= pd.to_datetime(df_bms['time'], format='%Y-%m-%d %H:%M:%S')
        # df_uniform['time']=pd.to_datetime(df_uniform['time'], format='%Y-%m-%d %H:%M:%S')

        self.df_uniform=df_uniform
        self.df_last3=df_last3
        self.df_lfp1=df_lfp1

        self.cellvolt_name=['CellVolt'+str(x) for x in range(1,self.param.CellVoltNums+1)]
        self.celltemp_name=['CellTemp'+str(x) for x in range(1,self.param.CellTempNums+1)]

    def batuniform(self):
        if self.celltype<50:
            df_res, df_ram_last3=self._ncm_uniform()
            return df_res, df_ram_last3, self.df_lfp1
        else:
            df_res, df_ram_last3, df_ram_lfp1=self._lfp_uniform()
            return df_res, df_ram_last3, df_ram_lfp1

    #定义滑动滤波函数........................................................................................................................................
    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 = list(self.df_bms.loc[num,self.celltemp_name])
        celltemp.remove(min(celltemp))
        self.celltemp=celltemp
        if self.celltype>50:
            if min(celltemp)>=25:
                self.tempweight=1
                self.StandardStandingTime=2400
            elif min(celltemp)>=15:
                self.tempweight=0.6
                self.StandardStandingTime=3600
            elif min(celltemp)>=5:
                self.tempweight=0.2
                self.StandardStandingTime=4800
            else:
                self.tempweight=0.1
                self.StandardStandingTime=7200
        else:
            if min(celltemp)>=25:
                self.tempweight=1
                self.StandardStandingTime=1800
            elif min(celltemp)>=15:
                self.tempweight=0.8
                self.StandardStandingTime=2400
            elif min(celltemp)>=5:
                self.tempweight=0.6
                self.StandardStandingTime=3600
            else:
                self.tempweight=0.2
                self.StandardStandingTime=7200

    #获取当前行所有电压数据............................................................................................................................
    def _cellvolt_get(self,num):
        cellvolt = np.array(self.df_bms.loc[num,self.cellvolt_name])
        return cellvolt

    #获取单个电压值.................................................................................................
    def _singlevolt_get(self,num,series,mode):  #mode==1取当前行单体电压值，mode==2取某个单体所有电压值
        s=str(series)
        if mode==1:
            singlevolt=self.df_bms.loc[num,'CellVolt' + s]
            return singlevolt
        else:
            singlevolt=self.df_bms['CellVolt' + s]
            return singlevolt

    #寻找DVDQ的峰值点，并返回..........................................................................................................................
    def _dvdq_peak(self, time, soc, cellvolt, packcrnt):
        cellvolt = self._np_move_avg(cellvolt, 3, mode="same")
        Soc = 0
        Ah = 0
        Volt = cellvolt[0]
        DV_Volt = []
        DQ_Ah = []
        DVDQ = []
        time1 = []
        soc1 = []
        soc2 = []
        xvolt=[]

        for m in range(1, len(time)):
            Step = (time[m] - time[m - 1]).total_seconds()
            Soc = Soc - packcrnt[m] * Step * 100 / (3600 * self.param.Capacity)
            Ah = Ah - packcrnt[m] * Step / 3600
            if (cellvolt[m]-Volt)>0.0019 and Ah>0:
                DQ_Ah.append(Ah)
                DV_Volt.append(cellvolt[m]-Volt)
                DVDQ.append((DV_Volt[-1])/Ah)
                xvolt.append(cellvolt[m])
                Volt=cellvolt[m]
                Ah = 0
                soc1.append(Soc)
                time1.append(time[m])
                soc2.append(soc[m])

        #切片，去除前后10min的数据
        df_Data1 = pd.DataFrame({'time': time1,
                                'SOC': soc2,
                                'DVDQ': DVDQ,
                                'AhSoc': soc1,
                                '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(time1)-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)]

        # print(packcrnt[int(len(time)/2)], min(self.celltemp))
        # ax1 = plt.subplot(3, 1, 1)
        # plt.plot(df_Data1['SOC'],df_Data1['DQ_Ah'],'g*-')
        # plt.xlabel('SOC/%')
        # plt.ylabel('DQ_Ah')
        # 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()

        if len(df_Data1)>2:     #寻找峰值点，且峰值点个数>2
            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 min(df_Data1['SOC'])+0.5<df_Data1['SOC'][PeakIndex]<max(df_Data1['SOC'])-1:
                return df_Data1['AhSoc'][PeakIndex]
            
            else:
                if min(df_Data1['SOC'])+0.5<df_Data1['SOC'][PeakIndex]<max(df_Data1['SOC'])-1:
                    df_Data1=df_Data1.drop([PeakIndex])
                elif df_Data1['SOC'][PeakIndex]>max(df_Data1['SOC'])-1:
                    df_Data1=df_Data1[df_Data1['SOC']<(df_Data1['SOC'][PeakIndex]-1)]
                else:
                    df_Data1=df_Data1[df_Data1['SOC']>(df_Data1['SOC'][PeakIndex]+0.5)]
                
                if len(df_Data1)>2:
                    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 min(df_Data1['SOC'])+0.5<df_Data1['SOC'][PeakIndex]<max(df_Data1['SOC'])-1:
                        return df_Data1['AhSoc'][PeakIndex]
                    else:
                        return 0
                else:
                    return 0
        else:
            return 0

    #三元电池一致性计算.................................................................................................................................
    def _ncm_uniform(self):
        column_name=['time','sn','cellsoc_diff','cellvolt_diff','cellmin_num','cellmax_num','cellvolt_rank']
        df_res=pd.DataFrame(columns=column_name)

        df_ram_last3=self.df_last3
        if df_ram_last3.empty:
            standingtime=0
            standingtime1=0
            standingtime2=0
        else:
            standingtime=df_ram_last3.loc[0,'standingtime']
            standingtime1=df_ram_last3.loc[0,'standingtime1']
            standingtime2=df_ram_last3.loc[0,'standingtime2']
            if abs(self.packcrnt[0])<0.01 and standingtime2>1:
                standingtime2=standingtime2+(self.bmstime[0]-df_ram_last3.loc[0,'time3']).total_seconds()
            else:
                pass


        for i in range(1,len(self.df_bms)-1):

            if abs(self.packcrnt[i]) < 0.1 and abs(self.packcrnt[i-1]) < 0.1:     #电流为0
                delttime=(self.bmstime[i]-self.bmstime[i-1]).total_seconds()
                standingtime2=standingtime2+delttime
                self._celltemp_weight(i)     #获取不同温度对应的静置时间

                if standingtime2>self.StandardStandingTime:      #静置时间满足要求
                    if abs(self.packcrnt[i+1]) >= 0.1:
                        standingtime2=0
                        cellvolt_now=self._cellvolt_get(i)
                        cellvolt_min=min(cellvolt_now)
                        cellvolt_max=max(cellvolt_now)
                        cellvolt_last=self._cellvolt_get(i-1)
                        deltvolt=max(abs(cellvolt_now-cellvolt_last))
                        if 3<cellvolt_min<4.5 and 3<cellvolt_max<4.5 and deltvolt<0.005:
                            cellvolt_sort=np.argsort(cellvolt_now)
                            cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                            cellmin_num=list(cellvolt_now).index(cellvolt_min)+1
                            cellmax_num=list(cellvolt_now).index(cellvolt_max)+1
                            cellsoc_min=np.interp(cellvolt_min,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellsoc_max=np.interp(cellvolt_max,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellvolt_diff=(cellvolt_max-cellvolt_min)*1000
                            cellsoc_diff=cellsoc_max-cellsoc_min
                            cellsoc_diff=eval(format(cellsoc_diff,'.1f'))
                            cellvolt_diff=eval(format(cellvolt_diff,'.0f'))
                            df_res.loc[len(df_res)]=[self.bmstime[i], self.sn, cellsoc_diff, cellvolt_diff, cellmin_num, cellmax_num, str(cellvolt_rank)]
                    elif standingtime2>3600:
                        cellvolt_now=self._cellvolt_get(i)
                        cellvolt_min=min(cellvolt_now)
                        cellvolt_max=max(cellvolt_now)
                        cellvolt_last=self._cellvolt_get(i-1)
                        deltvolt=max(abs(cellvolt_now-cellvolt_last))

                        if 3<cellvolt_min<4.5 and 3<cellvolt_max<4.5 and deltvolt<0.005:
                            standingtime2=0
                            cellvolt_sort=np.argsort(cellvolt_now)
                            cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                            cellmin_num=list(cellvolt_now).index(cellvolt_min)+1
                            cellmax_num=list(cellvolt_now).index(cellvolt_max)+1
                            cellsoc_min=np.interp(cellvolt_min,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellsoc_max=np.interp(cellvolt_max,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellvolt_diff=(cellvolt_max-cellvolt_min)*1000
                            cellsoc_diff=cellsoc_max-cellsoc_min
                            cellsoc_diff=eval(format(cellsoc_diff,'.1f'))
                            cellvolt_diff=eval(format(cellvolt_diff,'.0f'))
                            df_res.loc[len(df_res)]=[self.bmstime[i], self.sn, cellsoc_diff, cellvolt_diff, cellmin_num, cellmax_num, str(cellvolt_rank)]
                    elif i>=len(self.df_bms)-2:
                        cellvolt_now=self._cellvolt_get(i)
                        cellvolt_min=min(cellvolt_now)
                        cellvolt_max=max(cellvolt_now)
                        cellvolt_last=self._cellvolt_get(i-1)
                        deltvolt=max(abs(cellvolt_now-cellvolt_last))

                        if 3<cellvolt_min<4.5 and 3<cellvolt_max<4.5 and deltvolt<0.005:
                            standingtime2=0
                            cellvolt_sort=np.argsort(cellvolt_now)
                            cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                            cellmin_num=list(cellvolt_now).index(cellvolt_min)+1
                            cellmax_num=list(cellvolt_now).index(cellvolt_max)+1
                            cellsoc_min=np.interp(cellvolt_min,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellsoc_max=np.interp(cellvolt_max,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellvolt_diff=(cellvolt_max-cellvolt_min)*1000
                            cellsoc_diff=cellsoc_max-cellsoc_min
                            cellsoc_diff=eval(format(cellsoc_diff,'.1f'))
                            cellvolt_diff=eval(format(cellvolt_diff,'.0f'))
                            df_res.loc[len(df_res)]=[self.bmstime[i], self.sn, cellsoc_diff, cellvolt_diff, cellmin_num, cellmax_num, str(cellvolt_rank)]
                        break
                    else:
                        continue
                else:
                    continue
            else:
                standingtime2=0
                continue

        #更新RAM的standingtime
        df_ram_last3.loc[0]=[self.sn,self.bmstime[len(self.bmstime)-1],standingtime,standingtime1,standingtime2]

        if df_res.empty:    #返回计算结果
            return pd.DataFrame(), df_ram_last3
        else:
            return df_res, df_ram_last3

    #磷酸铁锂电池一致性计算.........................................................................................................................
    def _lfp_uniform(self):
        column_name=['time','sn','cellsoc_diff','cellvolt_diff','cellmin_num','cellmax_num','cellvolt_rank']
        df_res=pd.DataFrame(columns=column_name)
        df_ram_lfp1=pd.DataFrame(columns=self.df_bms.columns.tolist())
        chrg_start=[]
        chrg_end=[]
        charging=0

        df_ram_last3=self.df_last3
        if df_ram_last3.empty:
            standingtime=0
            standingtime1=0
            standingtime2=0
        else:
            standingtime=df_ram_last3.loc[0,'standingtime']
            standingtime1=df_ram_last3.loc[0,'standingtime1']
            standingtime2=df_ram_last3.loc[0,'standingtime2']
            if abs(self.packcrnt[0])<0.01 and standingtime2>1:
                standingtime2=standingtime2+(self.bmstime[0]-df_ram_last3.loc[0,'time3']).total_seconds()
            else:
                pass

        for i in range(1,len(self.df_bms)-1):

            #静置电压法计算电芯一致性
            if abs(self.packcrnt[i]) < 0.1 and abs(self.packcrnt[i-1]) < 0.1:     #电流为0
                delttime=(self.bmstime[i]-self.bmstime[i-1]).total_seconds()
                standingtime2=standingtime2+delttime
                self._celltemp_weight(i)     #获取不同温度对应的静置时间

                if standingtime2>self.StandardStandingTime:      #静置时间满足要求
                    if abs(self.packcrnt[i+1]) >= 0.1:
                        standingtime2=0
                        cellvolt_now=self._cellvolt_get(i)
                        cellvolt_min=min(cellvolt_now)
                        cellvolt_max=max(cellvolt_now)
                        cellvolt_last=self._cellvolt_get(i-1)
                        deltvolt=max(abs(cellvolt_now-cellvolt_last))

                        if 2 < cellvolt_max < self.param.OcvInflexionBelow-0.002 and 2<cellvolt_min<4.5 and deltvolt<0.005:
                            cellvolt_sort=np.argsort(cellvolt_now)
                            cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                            cellmin_num=list(cellvolt_now).index(cellvolt_min)+1
                            cellmax_num=list(cellvolt_now).index(cellvolt_max)+1
                            cellsoc_min=np.interp(cellvolt_min,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellsoc_max=np.interp(cellvolt_max,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellvolt_diff=(cellvolt_max-cellvolt_min)*1000
                            cellsoc_diff=cellsoc_max-cellsoc_min
                            cellsoc_diff=eval(format(cellsoc_diff,'.1f'))
                            cellvolt_diff=eval(format(cellvolt_diff,'.0f'))
                            df_res.loc[len(df_res)]=[self.bmstime[i], self.sn, cellsoc_diff, cellvolt_diff, cellmin_num, cellmax_num, str(cellvolt_rank)]
                        # elif 2<cellvolt_max<4.5 and 2<cellvolt_min<4.5 and deltvolt<0.005:
                        #     cellvolt_sort=np.argsort(cellvolt_now)
                        #     cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                        #     if not df_res.empty:
                        #         df_res.loc[len(df_res)]=df_res.loc[len(df_res)-1]
                        #         df_res.loc[len(df_res)-1,'cellvolt_rank']=str(cellvolt_rank)
                        #         df_res.loc[len(df_res)-1,'time']=self.bmstime[i]
                        #     elif not self.df_uniform.empty:
                        #         df_res.loc[len(df_res)]=self.df_uniform.iloc[-1]
                        #         df_res.loc[len(df_res)-1,'cellvolt_rank']=str(cellvolt_rank)
                        #         df_res.loc[len(df_res)-1,'time']=self.bmstime[i]
                        #     else:
                        #         pass
                    elif standingtime2>3600*6:
                        cellvolt_now=self._cellvolt_get(i)
                        cellvolt_min=min(cellvolt_now)
                        cellvolt_max=max(cellvolt_now)
                        cellvolt_last=self._cellvolt_get(i-1)
                        deltvolt=max(abs(cellvolt_now-cellvolt_last))

                        if 2 < cellvolt_max < self.param.OcvInflexionBelow-0.002 and 2<cellvolt_min<4.5 and deltvolt<0.005:
                            standingtime2=0
                            cellvolt_sort=np.argsort(cellvolt_now)
                            cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                            cellmin_num=list(cellvolt_now).index(cellvolt_min)+1
                            cellmax_num=list(cellvolt_now).index(cellvolt_max)+1
                            cellsoc_min=np.interp(cellvolt_min,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellsoc_max=np.interp(cellvolt_max,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellvolt_diff=(cellvolt_max-cellvolt_min)*1000
                            cellsoc_diff=cellsoc_max-cellsoc_min
                            cellsoc_diff=eval(format(cellsoc_diff,'.1f'))
                            cellvolt_diff=eval(format(cellvolt_diff,'.0f'))
                            df_res.loc[len(df_res)]=[self.bmstime[i], self.sn, cellsoc_diff, cellvolt_diff, cellmin_num, cellmax_num, str(cellvolt_rank)]
                        # elif 2<cellvolt_max<4.5 and 2<cellvolt_min<4.5 and deltvolt<0.005:
                        #     cellvolt_sort=np.argsort(cellvolt_now)
                        #     cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                        #     if not df_res.empty:
                        #         df_res.loc[len(df_res)]=df_res.loc[len(df_res)-1]
                        #         df_res.loc[len(df_res)-1,'cellvolt_rank']=str(cellvolt_rank)
                        #         df_res.loc[len(df_res)-1,'time']=self.bmstime[i]
                        #     elif not self.df_uniform.empty:
                        #         df_res.loc[len(df_res)]=self.df_uniform.iloc[-1]
                        #         df_res.loc[len(df_res)-1,'cellvolt_rank']=str(cellvolt_rank)
                        #         df_res.loc[len(df_res)-1,'time']=self.bmstime[i]
                        #     else:
                        #         pass

                    elif i>=len(self.df_bms)-2:
                        standingtime2=0
                        cellvolt_now=self._cellvolt_get(i)
                        cellvolt_min=min(cellvolt_now)
                        cellvolt_max=max(cellvolt_now)
                        cellvolt_last=self._cellvolt_get(i-1)
                        deltvolt=max(abs(cellvolt_now-cellvolt_last))
                        if 2 < cellvolt_max < self.param.OcvInflexionBelow-0.002 and 2<cellvolt_min<4.5 and deltvolt<0.003:
                            cellvolt_sort=np.argsort(cellvolt_now)
                            cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                            cellmin_num=list(cellvolt_now).index(cellvolt_min)+1
                            cellmax_num=list(cellvolt_now).index(cellvolt_max)+1
                            cellsoc_min=np.interp(cellvolt_min,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellsoc_max=np.interp(cellvolt_max,self.param.LookTab_OCV,self.param.LookTab_SOC)
                            cellvolt_diff=(cellvolt_max-cellvolt_min)*1000
                            cellsoc_diff=cellsoc_max-cellsoc_min
                            cellsoc_diff=eval(format(cellsoc_diff,'.1f'))
                            cellvolt_diff=eval(format(cellvolt_diff,'.0f'))
                            df_res.loc[len(df_res)]=[self.bmstime[i], self.sn, cellsoc_diff, cellvolt_diff, cellmin_num, cellmax_num, str(cellvolt_rank)]
                        # elif 2<cellvolt_max<4.5 and 2<cellvolt_min<4.5 and deltvolt<0.005:
                        #     cellvolt_sort=np.argsort(cellvolt_now)
                        #     cellvolt_rank=list(np.argsort(cellvolt_sort)+1)
                        #     if not df_res.empty:
                        #         df_res.loc[len(df_res)]=df_res.loc[len(df_res)-1]
                        #         df_res.loc[len(df_res)-1,'cellvolt_rank']=str(cellvolt_rank)
                        #         df_res.loc[len(df_res)-1,'time']=self.bmstime[i]
                        #     elif not self.df_uniform.empty:
                        #         df_res.loc[len(df_res)]=self.df_uniform.iloc[-1]
                        #         df_res.loc[len(df_res)-1,'cellvolt_rank']=str(cellvolt_rank)
                        #         df_res.loc[len(df_res)-1,'time']=self.bmstime[i]
                        #     else:
                        #         pass
                    else:
                        pass
                else:
                    pass
            else:
                standingtime2=0
                pass

            if i==len(self.df_bms)-2 and abs(self.packcrnt[i+1]) < 0.1:  #数据中断后仍在静置，将最后一条数据写入RAM
                df_ram_lfp1.loc[0]=self.df_bms.iloc[-1]
            else:
                pass

            #获取DVDQ算法所需数据——开始............................................................................................................
            if charging==0: #判断充电开始
                if self.packcrnt[i]<=-1 and self.packcrnt[i+1]<=-1 and self.bms_soc[i]<40:     #充电开始
                    charging=1
                    if len(chrg_start)>len(chrg_end):
                        chrg_start[-1]=i
                    else:
                        chrg_start.append(i)
                else:
                    pass

            else: #充电中
                if (self.bmstime[i+1]-self.bmstime[i]).total_seconds()>180 or (self.packcrnt[i]<-self.param.Capacity and self.packcrnt[i+1]<-self.param.Capacity):  #如果充电过程中时间间隔>180s，则舍弃该次充电
                    chrg_start.remove(chrg_start[-1])
                    charging=0
                    continue
                elif self.packcrnt[i]<=-1 and self.packcrnt[i-1]<=-1 and  self.packcrnt[i+1]>-1:  #判断电流波动时刻
                    cellvolt_now=self._cellvolt_get(i+1)
                    if max(cellvolt_now)>self.param.CellFullChrgVolt-0.1:   #电压>满充电压
                        chrg_end.append(i+1)
                        charging=0
                        continue
                    else:
                        pass
                elif self.packcrnt[i+1]>-0.1 and self.packcrnt[i]>-0.1:   #判断充电结束
                    charging=0
                    if len(chrg_start)>len(chrg_end):
                        if self.bms_soc[i]>90:
                            chrg_end.append(i)
                        else:
                            chrg_start.remove(chrg_start[-1])
                            continue
                    else:
                        continue
                elif i==len(self.packcrnt)-2 and self.packcrnt[i+1]<-1 and self.packcrnt[i]<-1:
                    charging=0
                    if len(chrg_start)>len(chrg_end) and self.bms_soc[i]>90:   #soc>90
                        chrg_end.append(i)
                        continue
                    else:
                        df_ram_lfp1=self.df_bms.iloc[chrg_start[-1]:]
                        chrg_start.remove(chrg_start[-1])
                        continue
                else:
                    continue

        if chrg_end:    #DVDQ方法计算soc差
            peaksoc_list=[]
            for i in range(len(chrg_end)):
                peaksoc_list = []
                self._celltemp_weight(chrg_start[i])
                if min(self.celltemp)>10:
                    for j in range(1, self.param.CellVoltNums + 1):
                        cellvolt = self._singlevolt_get(i,j,2)  #取单体电压j的所有电压值
                        cellvolt = list(cellvolt[chrg_start[i]:chrg_end[i]])
                        time = list(self.bmstime[chrg_start[i]:chrg_end[i]])
                        packcrnt = list(self.packcrnt[chrg_start[i]:chrg_end[i]])
                        soc = list(self.bms_soc[chrg_start[i]:chrg_end[i]])
                        peaksoc = self._dvdq_peak(time, soc, cellvolt, packcrnt)
                        if peaksoc>1:
                            peaksoc_list.append(peaksoc)    #计算到达峰值点的累计Soc
                        else:
                            pass
                    if len(peaksoc_list)>self.param.CellVoltNums/2:
                        peaksoc_max=max(peaksoc_list)
                        peaksoc_min=min(peaksoc_list)
                        peaksoc_maxnum=peaksoc_list.index(peaksoc_min)+1
                        peaksoc_minnum=peaksoc_list.index(peaksoc_max)+1
                        cellsoc_diff=peaksoc_max-peaksoc_min
                        cellsoc_diff=eval(format(cellsoc_diff,'.1f'))
                        if not df_res.empty:
                            cellvolt_rank=df_res.iloc[-1]['cellvolt_rank']
                            df_res.loc[len(df_res)]=[self.bmstime[chrg_start[i]], self.sn, cellsoc_diff, 0, peaksoc_minnum, peaksoc_maxnum, cellvolt_rank]
                        elif not self.df_uniform.empty:
                            cellvolt_rank=self.df_uniform.iloc[-1]['cellvolt_rank']
                            df_res.loc[len(df_res)]=[self.bmstime[chrg_start[i]], self.sn, cellsoc_diff, 0, peaksoc_minnum, peaksoc_maxnum, cellvolt_rank]
                        else:
                            pass
                    else:
                        pass
                else:
                    pass

        #更新RAM的standingtime
        df_ram_last3.loc[0]=[self.sn,self.bmstime[len(self.bmstime)-1],standingtime,standingtime1,standingtime2]

        if df_res.empty:
            return pd.DataFrame(), df_ram_last3, df_ram_lfp1
        else:
            df_res.sort_values(by='time', ascending=True, inplace=True)
            return df_res, df_ram_last3, df_ram_lfp1