zlwl-algos-new/USER/likun/testoneday/DataSplit/V_1_0_0/data_split.py

##对行驶、静置和充电数据进行分段，输入数据为标准化状态码的数据
import pandas as pd
import numpy as np

def split(df_merge,drive_interval_time_min=1200,charge_interval_time_min=1200,stand_interval_time_min=1200,single_num_min=3,drive_sts=3,charge_sts=[21,22],stand_sts=0):
    ##行驶段的划分，将行驶状态划分为不同的行驶段
    df_drive=df_merge[df_merge['bms_sta']==drive_sts]
    ###行驶时间段切割
    df_drive["order_delta"]= pd.to_datetime(df_drive["time"] )-pd.to_datetime( df_drive["time"].shift(1).fillna(method = 'backfill',axis = 0))
    df_drive["order_delta"]=pd.to_timedelta(df_drive["order_delta"])
    df_drive["order_delta"] = df_drive["order_delta"].dt.total_seconds()
    ##限定时间间隔1200秒切割和合并
    df_drive["time_flag"]=df_drive["order_delta"]>drive_interval_time_min
    df_drive['drive_block']=(df_drive["time_flag"].shift(1) != df_drive["time_flag"]).astype(int).cumsum()
    ##排除单点
    df_drive_count=df_drive.groupby(["sn","drive_block"]).agg({'time':'count'})
    df_drive_count=df_drive_count.reset_index()
    df_drive_count=df_drive_count[df_drive_count["time"]>single_num_min]
    df_drive_count_choice=df_drive_count[["sn","drive_block"]]
    df_drive=pd.merge(df_drive,df_drive_count_choice,on=['sn', 'drive_block'],how='inner')
    df_drive=df_drive.drop(['time_flag', 'order_delta'], axis=1, inplace=False)
    
    ##充电段的划分，将充电状态划分为不同的充电段
    df_charge=df_merge[df_merge['bms_sta'].isin(charge_sts)]
    ##充电时间段切割
    df_charge["order_delta"]= pd.to_datetime(df_charge["time"] )-pd.to_datetime( df_charge["time"].shift(1).fillna(method = 'backfill',axis = 0))
    df_charge["order_delta"]=pd.to_timedelta(df_charge["order_delta"])
    df_charge["order_delta"] = df_charge["order_delta"].dt.total_seconds()
    ##限定时间间隔1200秒切割和合并
    df_charge["time_flag"]=df_charge["order_delta"]>charge_interval_time_min
    df_charge['charge_block']=(df_charge["time_flag"].shift(1) != df_charge["time_flag"]).astype(int).cumsum()
    
    df_charge_count=df_charge.groupby(["sn","charge_block"]).agg({'time':'count'})
    df_charge_count=df_charge_count.reset_index()
    df_charge_count=df_charge_count[df_charge_count["time"]>single_num_min]
    df_charge_count_choice=df_charge_count[["sn","charge_block"]]
    df_charge=pd.merge(df_charge,df_charge_count_choice,on=['sn', 'charge_block'],how='inner')
    df_charge=df_charge.drop(['time_flag', 'order_delta'], axis=1, inplace=False)
    
    ##静置段的划分，将静置状态划分为不同的静置段
    df_stand=df_merge[df_merge['bms_sta']==stand_sts]
    ##静置时间段切割
    df_stand["order_delta"]= pd.to_datetime(df_stand["time"] )-pd.to_datetime( df_stand["time"].shift(1).fillna(method = 'backfill',axis = 0))
    df_stand["order_delta"]=pd.to_timedelta(df_stand["order_delta"])
    df_stand["order_delta"] = df_stand["order_delta"].dt.total_seconds()
    ##限定时间间隔1200秒切割和合并
    df_stand["time_flag"]=df_stand["order_delta"]>stand_interval_time_min
    df_stand['stand_block']=(df_stand["time_flag"].shift(1) != df_stand["time_flag"]).astype(int).cumsum()
    
    df_stand_count=df_stand.groupby(["sn","stand_block"]).agg({'time':'count'})
    df_stand_count=df_stand_count.reset_index()
    df_stand_count=df_stand_count[df_stand_count["time"]>single_num_min]
    df_stand_count_choice=df_stand_count[["sn","stand_block"]]
    df_stand=pd.merge(df_stand,df_stand_count_choice,on=['sn', 'stand_block'],how='inner')
    df_stand=df_stand.drop(['time_flag', 'order_delta'], axis=1, inplace=False)
    
    return df_drive,df_charge,df_stand