import pandas as pd import numpy as np import time, datetime class cell_statistic: def __init__(self, df_algo_pack_param, df_bms): #参数初始化 self.sn = df_bms['sn'].iloc[0] self.df_bms=pd.DataFrame(df_bms) self.bmstime= pd.to_datetime(df_bms['time'], format='%Y-%m-%d %H:%M:%S') self.CellVoltNums = int(df_algo_pack_param['CellVoltTotalCount']) self.CellTempNums = int(df_algo_pack_param['CellTempTotalCount']) self.cellvolt_list=['cell_voltage'+str(x) for x in range(1,self.CellVoltNums+1)] self.celltemp_name=['cell_temp'+str(x) for x in range(1,self.CellTempNums+1)] self.capty = 2*float(int(df_algo_pack_param['capacity'])) #.............................................静置行为统计............................................................................ def rest_sta(self): def clean_dead_value(series, num_dead_thresh): slide_list = [series.index[0]] slide_list_all = [] for i in range(series.index[0],series.index[-1]): j = i + 1 diff = series[j] - series[i] if diff == 0: slide_list.append(j) else: slide_list.clear() slide_list.append(j) if len(slide_list) >= num_dead_thresh: target_list = slide_list.copy() slide_list_all.append(target_list) index= [] # 将找到的满足条件的index合并 for i in range(len(slide_list_all) - 1): if set(slide_list_all[i]) < set(slide_list_all[i + 1]): index.append(i) m = {i: element for i, element in enumerate(slide_list_all)} [m.pop(i) for i in index] return list(m.values()) df_data = self.df_bms.copy() df_data['crnt_flg'] = 0 df_data.loc[df_data['pack_crnt'] > 0, 'crnt_flg'] = 1 df_data.loc[df_data['pack_crnt'] < -15, 'crnt_flg'] = -1 df_data['sts_flg'] = 2 df_sts_chrg = pd.DataFrame(columns=list(df_data.columns)) df_crnt_flg = df_data['crnt_flg'] num_dead_thresh = 15#判断连续多少个数据为阈值 indexs_to_delelte = clean_dead_value(df_crnt_flg, num_dead_thresh)#获得连续数据所在的行 rest_num = len(indexs_to_delelte) if rest_num > 0:#仅有一个连续数据时 for splice_item in range(0, rest_num):#rest_num df_data_temp = df_data.iloc[indexs_to_delelte[splice_item][0]:indexs_to_delelte[splice_item][-1]]#获得电流连续数据 df_data_temp.reset_index(drop = True, inplace = True) df_soc_temp = df_data_temp['pack_soc'] delta_soc = round((df_soc_temp.iloc[-1] - df_soc_temp.iloc[0]), 3) df_time_temp = pd.to_datetime(df_data_temp['time']) delta_time = (df_time_temp.iloc[-1] - df_time_temp.iloc[0])/pd.Timedelta(1, 'hours') if all(df_data_temp['crnt_flg'] == 0):#静置判断 if delta_time > 0.17: df_data_temp['sts_flg'] = 0 df_sts_chrg = df_sts_chrg.append(df_data_temp) df_sts_chrg.reset_index(drop = True, inplace = True) elif all(df_data_temp['crnt_flg'] == -1) and (delta_soc > 30) and (delta_soc < 100):#充电判断 df_data_temp['sts_flg'] = 1 df_sts_chrg = df_sts_chrg.append(df_data_temp) df_sts_chrg.reset_index(drop = True, inplace = True) elif all(df_data_temp['crnt_flg'] == 1) and (delta_soc > 30) and (delta_soc < 100):#充电判断 df_data_temp['sts_flg'] = 1 df_sts_chrg = df_sts_chrg.append(df_data_temp) df_sts_chrg.reset_index(drop = True, inplace = True) df_dschrg = pd.concat([df_data, df_sts_chrg, df_sts_chrg]).drop_duplicates(subset = ['time', 'pack_soc'], keep = False) data_temp = pd.concat([df_dschrg, df_sts_chrg]) data_temp.sort_values(by = 'time', inplace = True) data_temp.reset_index(drop = True, inplace = True) start_time = time.time() chrgrststs_clumns = ['sn', 'time_st', 'time_end', 'delta_time','soc_st', 'soc_sp', 'delta_soc', 'odo_st', 'odo_sp', 'delta_odo','chrgah', 'equchrgah','gps_lon','gps_lat','meancrnt', 'sts_flg', 'full_chrg_flg', 'crnt_aray', 'soc_aray', 'celtemmax', 'celtemmin', 'celvltmax', 'timelst', 'chrgahlst', "packvlt"] df_sts_chrg_rlt = pd.DataFrame(columns = chrgrststs_clumns)#充电与静置 if len(data_temp) > 30: #---------------------------------充电过程判断-------------------------------------- df_chrg_temp = data_temp.loc[(data_temp['sts_flg'] == 1)] if not df_chrg_temp.empty: df_chrg_temp.reset_index(inplace = True, drop = True) chrgr_time = pd.to_datetime(df_chrg_temp['time']) delta_time = (np.diff(chrgr_time)/pd.Timedelta(1, 'min'))#计算时间差的分钟数 pos = np.where(delta_time > 10)#充电数据分段,大于10min时，认为是两个充电过程 splice_num = [] if len(pos[0]) >= 1: pos_ful_tem = np.insert(pos, 0, 0) pos_len = len(pos_ful_tem) data_len = len(chrgr_time) pos_ful = np.insert(pos_ful_tem, pos_len, data_len-1) for item in range(0,len(pos_ful)-1): splice_num.extend(item*np.ones(pos_ful[item +1]-pos_ful[item])) splice_num = np.insert(splice_num, 0, 0) else: splice_num = np.zeros(len(chrgr_time)) pos_ful = np.array([0]) if len(splice_num) > 0: df_chrg_temp['chrgr_rest'] = splice_num chrgr_splice_num = np.unique(df_chrg_temp['chrgr_rest'])#判断有几段充电数据 if len(chrgr_splice_num) > 0: for item_chrgr in chrgr_splice_num: df_chrgr_splice_temp_chs = df_chrg_temp.loc[df_chrg_temp['chrgr_rest'] == item_chrgr] df_chrgr_splice_temp_chs.reset_index(inplace = True, drop = True) df_chrgr_splice_temp = df_chrgr_splice_temp_chs[(df_chrgr_splice_temp_chs[self.cellvolt_list] > 2).all(axis = 1) & (df_chrgr_splice_temp_chs[self.cellvolt_list] < 5).all(axis = 1)] df_chrgr_splice_temp.reset_index(drop = True, inplace = True) if len(df_chrgr_splice_temp) > 10: df_tem = df_chrgr_splice_temp[self.celltemp_name] celltemmax = df_tem.max(axis = 1)#每一时刻内阻最大温度 celltemmin = df_tem.min(axis = 1)#每一时刻内阻最大温度 df_celvlt = df_chrgr_splice_temp[self.cellvolt_list] cellvltmax = df_celvlt.max(axis = 1) # df_clslst = df_celvlt.tail(1) # valueset = np.sort(df_clslst.iloc[0].unique()) # valuesort = [i for i in valueset if (i > 2) and (i < 5)] # if len(valuesort) >= 3: # maxclt = valuesort[-1] # secmaxcle = valuesort[-2] # thrdmaxcle = valuesort[-3] # else: # maxclt = valuesort[-1] # secmaxcle = valuesort[-1] # thrdmaxcle = valuesort[-1] # maxcell = df_clslst.columns[df_clslst.loc[len(df_celvlt) - 1].isin([maxclt])] # seccell = df_clslst.columns[df_clslst.loc[len(df_celvlt) - 1].isin([secmaxcle])] # thrdcell = df_clslst.columns[df_clslst.loc[len(df_celvlt) - 1].isin([thrdmaxcle])] # df_cellvlt_max = df_celvlt[maxcell[0]] # df_cellvlt_secmax = df_celvlt[seccell[0]] # df_cellvlt_thrdmax = df_celvlt[thrdcell[0]] df_cellvlt = pd.concat([cellvltmax, celltemmax, celltemmin], axis = 1) df_cellvlt.columns = ['maxvlt', 'maxtem', 'mintem'] df_data_tem = df_chrgr_splice_temp[['time','sn', 'pack_crnt','pack_volt','pack_soc', 'mileage','longitude', 'latitude']] df_chrgr_splice_data = pd.concat([df_data_tem, df_tem, df_cellvlt], axis = 1) df_time_temp = pd.to_datetime(df_chrgr_splice_data['time']) df_soc_temp = df_chrgr_splice_data['pack_soc'] df_crnt = df_chrgr_splice_data['pack_crnt'] df_odo = df_chrgr_splice_data['mileage'] df_maxvlt = df_chrgr_splice_data['maxvlt'] delta_soc = round((df_soc_temp.iloc[-1] - df_soc_temp.iloc[0]), 3) delta_odo = round((df_odo.iloc[-1] - df_odo.iloc[0]), 3) np_equah = round(delta_soc*self.capty/100, 3) delta_time = round((df_time_temp.iloc[-1] - df_time_temp.iloc[0])/pd.Timedelta(1, 'hours'), 3) if (delta_soc >= 3) and (df_soc_temp.iloc[0] < 45) and (df_soc_temp.iloc[-1] > 97) and (df_maxvlt.iloc[-1] > 3.5): socnum = df_soc_temp.value_counts() #统计电芯数量这一列每个元素出现的个数 socmax = socnum.idxmax() df_datacal = df_chrgr_splice_data.loc[df_chrgr_splice_data['pack_soc'] == socmax] df_datacal.reset_index(drop = True, inplace = True) np_dff_timetp = np.diff(pd.to_datetime(df_datacal['time']))/pd.Timedelta(1, 'hours') np_dff_time_newtp = np.append(np_dff_timetp, 0) np_chrg_ahtp = np.multiply(np.array(np_dff_time_newtp),np.array(df_datacal['pack_crnt'])) chrg_ahtp = np_chrg_ahtp.sum() chrgsoc = 100*chrg_ahtp/self.capty np_dffsoc = abs(np.diff(df_soc_temp)) if all(np_dffsoc < 3) and (abs(chrgsoc)<2.5): rate_chrg = round(delta_soc/(100*delta_time), 2) np_dff_time = np.diff(df_time_temp)/pd.Timedelta(1, 'hours') np_dff_time_new = np.append(np_dff_time, 0) np_chrg_ah = np.multiply(np.array(np_dff_time_new),np.array(df_crnt)) chrg_ah = np_chrg_ah.sum() chrg_ahlst = [] for ah_k in range(1, len(np_chrg_ah)+1): chrg_ahlst.append(abs(round(np.sum(np_chrg_ah[:ah_k]), 3))) if rate_chrg > 0.001: stat_flg = 1#快充 else: stat_flg = 2#慢充 if df_soc_temp.iloc[-1] >= 98: full_chg_flg = 1#满充 else: full_chg_flg = 0 if stat_flg == 1: soc_st = int(df_soc_temp.iloc[0]) soc_sp = int(df_soc_temp.iloc[-1]) poslst = range(0, len(df_soc_temp), 1) df_chse_data = df_chrgr_splice_data.iloc[poslst] chrgahlst=chrg_ahlst[::1] crnt_ary=list(df_chse_data['pack_crnt']) soc_ary=list(df_chse_data['pack_soc']) cell_tem_max=list(df_chse_data['maxtem']) cell_tem_min=list(df_chse_data['mintem']) maxvlt=list(df_chse_data['maxvlt']) # secvlt=list(df_chse_data['secmaxvlt']) # thrdvlt=list(df_chse_data['thrdmaxvlt']) timearary=list(df_chse_data['time'].dt.strftime("%Y-%m-%d %H:%M:%S")) crntlst = [round(i,4) for i in crnt_ary] pack_vlt = list(df_chse_data['pack_volt']) df_sts_chrg_temp = pd.DataFrame({"sn":[self.sn], "time_st":[df_time_temp.iloc[0].strftime('%Y-%m-%d %H:%M:%S')], "time_end":[df_time_temp.iloc[-1]], "delta_time":[delta_time], "soc_st":[soc_st], "soc_sp":[soc_sp], "delta_soc":[delta_soc], "odo_st":[df_odo.iloc[0]], "odo_sp":[df_odo.iloc[-1]], "delta_odo":[delta_odo], "chrgah":[chrg_ah], "equchrgah":[np_equah], "gps_lon":[df_chrgr_splice_data.loc[0, 'longitude']], "gps_lat":[df_chrgr_splice_data.loc[0, 'latitude']], "meancrnt":[rate_chrg], "sts_flg":[stat_flg], "full_chrg_flg":[full_chg_flg], "crnt_aray":[str(crntlst)], "soc_aray":[str(soc_ary)],"celtemmax":[str(cell_tem_max)], "celtemmin":[str(cell_tem_min)], "celvltmax":[str(maxvlt)], "timelst":[str(timearary)], "chrgahlst":[str(chrgahlst)], "packvlt":[str(pack_vlt)]}) df_sts_chrg_rlt = df_sts_chrg_rlt.append(df_sts_chrg_temp) df_sts_chrg_rlt.reset_index(drop = True, inplace = True) df_sts_chrg_rt = df_sts_chrg_rlt.copy() df_sts_chrg_rt.sort_values(by = ['time_st'], axis = 0, ascending=True, inplace=True)#对故障信息按照时间进行排序 end_time = time.time() if not df_sts_chrg_rt.empty: return df_sts_chrg_rt else: return pd.DataFrame()