In [9]:
from __future__ import division
# from pulp import *
import os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import matplotlib.mlab as mlab
import pandas as pd
import csv
import datetime
import sqlite3
import math
import seaborn as sns
%matplotlib inline
from pandas import *
from scipy import optimize
from scipy import stats
from datetime import date, timedelta
import timeit
from collections import OrderedDict
from IPython.display import clear_output
from IPython.display import HTML
from matplotlib.ticker import MultipleLocator
In [17]:
from sqlite3 import OperationalError
def query_EVSE_eventids(startdate, enddate):
# Query each event, for each event run the optimization based on corresponding energy cost to minimize
# the sum of energy cost every 15 minutes.
print('Start to query EV power at "Alcopark"')
# Get distinct event_ids for
conn = sqlite3.connect("sessionData2016.db")
cursor = conn.cursor()
query=("SELECT DISTINCT(DRIVER_ID) FROM sessionData2016")
query_cond1=("where ENERGY>0 and ENERGY!='' AND")
query_cond2=("STATION LIKE '%ALCO%' AND") # ALCOBASE
query_cond4=("(strftime(SESSION_START_TIME) between ") # MONTH IN JAN
cur = cursor.execute(query+" "+query_cond1+" "+query_cond2+" "+query_cond4+"'"+startdate+"'"+' AND '+"'"+enddate+"'"+')')
rows = cur.fetchall()
driver_ids=[]
for row in rows: driver_ids.append(row[0])
driver_ids=np.array(driver_ids)
driver_dicts={}
for driver_id in driver_ids:
try:
query=("SELECT DISTINCT(EVENT_ID) FROM sessionData2016 WHERE DRIVER_ID=")
query_cond=str(driver_id)
query_cond1=(" AND ENERGY>0 and ENERGY!='' AND")
query_cond2=("STATION LIKE '%ALCO%' AND") # ALCOPARK BASE
query_cond4=("strftime(SESSION_START_TIME) between ") # MONTH IN JAN
cur = cursor.execute(query+" "+query_cond+ " "+query_cond1+" "+query_cond2+" "+query_cond4+"'"+startdate+"'"+' AND '+"'"+enddate+"'")
rows = cur.fetchall()
event_ids=[]
for row in rows: event_ids.append(row[0])
driver_dicts.update({driver_id:event_ids})
except OperationalError:
print('Oops! That was no valid Driver ID: ' + str(driver_id))
conn.close()
return driver_dicts
In [18]:
driver_dicts=query_EVSE_eventids('1/1/16', '8/1/16')
In [58]:
print ('There are '+str(len(driver_dicts))+" drivers at AlcoBASE")
In [27]:
# query event_ids for driver_id with the most charging events
ordered_driver = OrderedDict(sorted(driver_dicts.viewitems(), key=lambda x: len(x[1]), reverse=True))
def query_driver_sessions(startdate, enddate, ranks):
for rank in range(ranks):
Driver_Power = pd.DataFrame([])
event_ids = ordered_driver.values()[rank]
for event_id in event_ids:
conn = sqlite3.connect("minData2016.db")
cursor = conn.cursor()
# FORM A QUERY TO GET RELEVANT DATA, MAKE SURE TO FLOOR THE STARTING OR ENDING POINT
# THIS WUERY WILL RETURN INTERVAL_ENERGY IN KWH, THIS REALLY IS WHAT WE ARE INTERESTED IN FOR OPTIMIZATION
# WE WILL NEED THE TIME FIELD TO GET THE CORRESPONDING VALUES OF ENERGY COST
# THE REST WILL BE USED WHEN POPULATING THE MINDATA DATABASE
query=("SELECT INTERVAL_START_DATE AS START,INTERVAL_END_DATE AS END,AVERAGE_POWER,ENERGY FROM minData2016 WHERE ENERGY!='' AND EVENT_ID=")
query_cond=str(event_id)
cur = cursor.execute(query+query_cond)
df = pd.DataFrame(cur.fetchall())
df.columns=['start','end','power','cumulative_energy']
df['StartDate'] = df['start'].apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
df.index = df['StartDate']
try:
df = df.resample('15min').bfill()
df = df.rename(columns = {'power':event_id})
Driver_Power = pd.concat([Driver_Power,pd.DataFrame(df[event_id])], axis = 1)
except ValueError:
print('Oops! That was no valid Event ID: ' + str(event_id))
return Driver_Power
In [28]:
Driver_Power=query_driver_sessions('1/1/16', '2/1/16',1)
In [64]:
# query event_ids for driver_id with the most charging events
ordered_driver = OrderedDict(sorted(driver_dicts.viewitems(), key=lambda x: len(x[1]), reverse=True))
def query_event_sessions(startdate, enddate, ranks):
for rank in range(ranks):
Driver_Power = pd.DataFrame([])
event_ids = ordered_driver.values()[rank]
for event_id in event_ids:
conn = sqlite3.connect("sessionData2016.db")
cursor = conn.cursor()
# FORM A QUERY TO GET RELEVANT DATA, MAKE SURE TO FLOOR THE STARTING OR ENDING POINT
# THIS WUERY WILL RETURN INTERVAL_ENERGY IN KWH, THIS REALLY IS WHAT WE ARE INTERESTED IN FOR OPTIMIZATION
# WE WILL NEED THE TIME FIELD TO GET THE CORRESPONDING VALUES OF ENERGY COST
# THE REST WILL BE USED WHEN POPULATING THE MINDATA DATABASE
query=("SELECT EVENT_ID, SESSION_START_TIME AS START,SESSION_END_TIME AS END, SESSION_LENGTH AS LENGTH, ENERGY, STATION FROM sessionData2016 WHERE ENERGY!='' AND EVENT_ID=")
query_cond=str(event_id)
cur = cursor.execute(query+query_cond)
df = pd.DataFrame(cur.fetchall())
df.columns=['event_id','start','end','length','cumulative_energy','station']
# df['StartDate'] = df['start'].apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
# df.index = event_id
try:
# df = df.resample('15min').bfill()
# df = df.rename(columns = {'power':event_id})
Driver_Power = pd.concat([Driver_Power,df])
except ValueError:
print('Oops! That was no valid Event ID: ' + str(event_id))
Driver_Power.to_csv('results/FlexDrivers/2016EVData/'+ordered_driver.keys()[rank]+'_EventSessions.csv')
return Driver_Power
In [65]:
event_sessions = query_event_sessions('1/1/16','12/31/16',len(ordered_driver))
In [116]:
import math
event_sessions = pd.read_csv('results/FlexDrivers/2016EVData/'+ordered_driver.keys()[0]+'_EventSessions.csv')
# event_sessions.index = event_sessions.ix[:,0].apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
event_sessions.drop(event_sessions.columns[[0]], axis=1, inplace=True)
event_sessions.start = event_sessions.start.apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
event_sessions.end = event_sessions.end.apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
event_sessions['duration'] = (event_sessions.end - event_sessions.start).apply(lambda x: timedelta.total_seconds(x) / 3600)
event_sessions['time'] = map(lambda x: x.strftime('%H:%M'),event_sessions.start)
event_sessions['timestamp'] = event_sessions.time.apply(lambda x: int(x.split(':')[0])*3600 + int(x.split(':')[0])*60)
In [149]:
sns.set_context('poster')
for i in range(len(ordered_driver)):
event_sessions = pd.read_csv('results/FlexDrivers/2016EVData/'+ordered_driver.keys()[i]+'_EventSessions.csv')
# event_sessions.index = event_sessions.ix[:,0].apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
event_sessions.drop(event_sessions.columns[[0]], axis=1, inplace=True)
event_sessions.start = event_sessions.start.apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
event_sessions.end = event_sessions.end.apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
event_sessions['duration'] = (event_sessions.end - event_sessions.start).apply(lambda x: timedelta.total_seconds(x) / 3600)
event_sessions['time'] = map(lambda x: x.strftime('%H:%M'),event_sessions.start)
event_sessions['hour'] = map(lambda x: int(x.strftime('%H')),event_sessions.start)
event_sessions['timestamp'] = event_sessions.time.apply(lambda x: int(x.split(':')[0])*3600 + int(x.split(':')[0])*60)
fig, (axes) = plt.subplots(1,1,figsize=(9, 5), facecolor='w', edgecolor='k', sharey=True)
fig.subplots_adjust(hspace = .1, wspace=.1)
axes.scatter(event_sessions.timestamp / 3600, event_sessions.duration, alpha=0.5)
axes.set_ylabel('Charging Session Length, [hour]')
axes.set_xlabel('Session Start Time')
majorLocator = MultipleLocator(2)
minorLocator = MultipleLocator(1)
axes.set_xlim(0,24)
axes.xaxis.set_major_locator(majorLocator)
# axes.set_xticklabels(range(-2,26,2))
axes.set_title('Drivers Charging Sessions (DriverID:'+ordered_driver.keys()[i]+')')
fig.savefig('results/FlexDrivers/2016EVData/'+'Session_'+ordered_driver.keys()[i]+'.png', dpi=300, format='png',bbox_inches='tight')
fig, (ax1, ax2) = plt.subplots(1,2, figsize=(18, 6), facecolor='w', edgecolor='k', sharex=False)
sns.distplot(event_sessions.hour, bins=range(24), ax = ax1)
sns.distplot(event_sessions.duration, bins=range(100), color = 'green',ax = ax2)
ax1.set_ylabel('Probability')
ax1.set_xlabel('Hour of Day')
ax1.set_title('Distribution of Arrival Time')
ax1.set_xlim(0,24)
ax2.set_ylabel('Probability')
ax2.set_xlabel('Hours')
ax2.set_title('Distribution of Session Length')
ax2.set_xlim(0,100)
fig.savefig('results/FlexDrivers/2016EVData/'+'SessionLength_'+ordered_driver.keys()[i]+'.png', dpi=300, format='png',bbox_inches='tight')
In [143]:
event_sessions
Out[143]:
Load flexibility depends on the charging duration and the overall flexibility as the ratio of the duration that a car is plugged but not charging to the overall session duration.
$$l_{flex}=\frac{d_{session}-d_{charge}}{d_{session}}$$
In [48]:
def query_driver_sessions(startdate, enddate, ranks):
for rank in range(ranks):
Driver_Power = pd.DataFrame([])
event_ids = ordered_driver.values()[rank]
for event_id in event_ids:
conn = sqlite3.connect("minData2016.db")
cursor = conn.cursor()
# FORM A QUERY TO GET RELEVANT DATA, MAKE SURE TO FLOOR THE STARTING OR ENDING POINT
# THIS WUERY WILL RETURN INTERVAL_ENERGY IN KWH, THIS REALLY IS WHAT WE ARE INTERESTED IN FOR OPTIMIZATION
# WE WILL NEED THE TIME FIELD TO GET THE CORRESPONDING VALUES OF ENERGY COST
# THE REST WILL BE USED WHEN POPULATING THE MINDATA DATABASE
query=("SELECT INTERVAL_START_DATE AS START,INTERVAL_END_DATE AS END,AVERAGE_POWER,ENERGY FROM minData2016 WHERE ENERGY!='' AND EVENT_ID=")
query_cond=str(event_id)
cur = cursor.execute(query+query_cond)
df = pd.DataFrame(cur.fetchall())
df.columns=['start','end','power','cumulative_energy']
df['StartDate'] = df['start'].apply(lambda x: datetime.strptime(x,'%m/%d/%y %H:%M'))
df.index = df['StartDate']
try:
df = df.resample('15min').bfill()
df = df.rename(columns = {'power':event_id})
Driver_Power = pd.concat([Driver_Power,pd.DataFrame(df[event_id])], axis = 1)
except ValueError:
print('Oops! That was no valid Event ID: ' + str(event_id))
try:
# Save each driver's all charging sessions into csv
Driver_Power.to_csv('results/FlexDrivers/2016EVData/'+ordered_driver.keys()[rank]+'.csv')
# Summarize Each Driver's Charging Behaviours
Driver_Status = pd.DataFrame()
Driver_Status['power'] = Driver_Power.power
Driver_Status=Driver_Status.fillna(-1)
for i in range(len(Driver_Status.columns)):
Driver_Status.loc[Driver_Status[Driver_Status.columns[i]] > 0,Driver_Status.columns[i]] = 1
# Create each driver's charging behavior to csv
Driver_Summary=Driver_Status
Driver_Summary['day'] = map(lambda x: x.strftime('%Y-%m-%d'),Driver_Summary.index)
Driver_Summary['hour'] = map(lambda x: x.strftime('%H'),Driver_Summary.index)
Driver_Summary['hour'] = Driver_Summary.hour.astype(int)
Driver_Summary['power'] = Driver_Summary.power.astype(int)
with open('results/FlexDrivers/2016EVFlexSummary/'+ordered_driver.keys()[rank]+'_summary.csv','wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
header = ['day', 'StartTime','ChargingLength','SessionLength', 'Flexibility']
writer.writerow(header)
for day in sorted(set(Driver_Summary['day'])):
df1 = Driver_Summary.loc[(Driver_Summary['power'] >= 0) & (Driver_Summary['day'] == day)]
df2 = Driver_Summary.loc[(Driver_Summary['power'] >= 1) & (Driver_Summary['day'] == day)]
SessionLength = timedelta.total_seconds(df1.index[-1]-df1.index[0])
ChargingLength = timedelta.total_seconds(df2.index[-1]-df2.index[0])
if SessionLength != 0:
Flexibility = (SessionLength-ChargingLength)/SessionLength
else:
Flexibility = 0
StartTime = df1.index[0].strftime('%H:%M')
writer.writerow([day, StartTime,ChargingLength,SessionLength, Flexibility])
print("EV Driver " + ordered_driver.keys()[rank] + " is Good")
except AttributeError:
print('Oops! That was no valid Event ID: ' + str(event_id))
In [49]:
query_driver_sessions('1/1/16', '12/31/16',2)
In [56]:
Driver_Power = pd.read_csv('results/FlexDrivers/2016EVData/'+ordered_driver.keys()[0]+'.csv')
Driver_Power.index = Driver_Power.ix[:,0].apply(lambda x: datetime.strptime(x,'%Y-%m-%d %H:%M:%S'))
Driver_Power.drop(Driver_Power.columns[[0]], axis=1, inplace=True)
Driver_Power.dropna(axis=1, how='all')
# Summarize Each Driver's Charging Behaviours
Driver_Status = pd.DataFrame()
for eventid in Driver_Power.columns:
Driver_Status['power'] = Driver_Power[eventid]
Driver_Status=Driver_Status.fillna(-1)
for i in range(len(Driver_Status.columns)):
Driver_Status.loc[Driver_Status[Driver_Status.columns[i]] > 0,Driver_Status.columns[i]] = 1
# Create each driver's charging behavior to csv
Driver_Summary=Driver_Status
Driver_Summary['day'] = map(lambda x: x.strftime('%Y-%m-%d'),Driver_Summary.index)
Driver_Summary['hour'] = map(lambda x: x.strftime('%H'),Driver_Summary.index)
Driver_Summary['hour'] = Driver_Summary.hour.astype(int)
Driver_Summary['power'] = Driver_Summary.power.astype(int)
with open('results/FlexDrivers/2016EVFlexSummary/'+ordered_driver.keys()[0]+'_summary.csv','wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
header = ['day', 'StartTime','ChargingLength','SessionLength', 'Flexibility']
writer.writerow(header)
for day in sorted(set(Driver_Summary['day'])):
df1 = Driver_Summary.loc[(Driver_Summary['power'] >= 0) & (Driver_Summary['day'] == day)]
df2 = Driver_Summary.loc[(Driver_Summary['power'] >= 1) & (Driver_Summary['day'] == day)]
SessionLength = timedelta.total_seconds(df1.index[-1]-df1.index[0])
ChargingLength = timedelta.total_seconds(df2.index[-1]-df2.index[0])
if SessionLength != 0:
Flexibility = (SessionLength-ChargingLength)/SessionLength
else:
Flexibility = 0
StartTime = df1.index[0].strftime('%H:%M')
writer.writerow([day, StartTime,ChargingLength,SessionLength, Flexibility])
In [129]:
ordered_driver = OrderedDict(sorted(driver_dicts.viewitems(), key=lambda x: len(x[1]), reverse=True))
# stat summary of start time of all drivers
with open('results/FlexDrivers/'+'StartTime_summary.csv','wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
header = ['driverid','count', 'mean','std','min', '10%','25%', '50%', '75%','90%', 'max']
writer.writerow(header)
for rank in range(len(ordered_driver.keys())):
df = pd.read_csv('results/FlexDrivers/EVFlexSummary/'+ordered_driver.keys()[rank]+'_summary.csv')
df['StartSeconds'] = map(lambda x: int(x.split(":")[0]) * 3600 + int(x.split(":")[1]) * 60,df['StartTime'])
writer.writerow([ordered_driver.keys()[rank],len(df['StartSeconds']),df['StartSeconds'].mean(),
df['StartSeconds'].std(),df['StartSeconds'].min(),np.percentile(df['StartSeconds'],10),
np.percentile(df['StartSeconds'],25),
np.percentile(df['StartSeconds'],50),np.percentile(df['StartSeconds'],75),
np.percentile(df['StartSeconds'],90),df['StartSeconds'].max()])
# stat summary of charging length of all drivers
with open('results/FlexDrivers/'+'ChargingLength_summary.csv','wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
header = ['driverid','count', 'mean','std','min', '10%','25%', '50%', '75%','90%', 'max']
writer.writerow(header)
for rank in range(len(ordered_driver.keys())):
df = pd.read_csv('results/FlexDrivers/EVFlexSummary/'+ordered_driver.keys()[rank]+'_summary.csv')
writer.writerow([ordered_driver.keys()[rank],len(df['ChargingLength']),df['ChargingLength'].mean(),
df['ChargingLength'].std(),df['ChargingLength'].min(),np.percentile(df['ChargingLength'],10),
np.percentile(df['ChargingLength'],25),
np.percentile(df['ChargingLength'],50),np.percentile(df['ChargingLength'],75),
np.percentile(df['ChargingLength'],90),df['ChargingLength'].max()])
# stat summary of session length of all drivers
with open('results/FlexDrivers/'+'SessionLength_summary.csv','wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
header = ['driverid','count', 'mean','std','min', '10%','25%', '50%', '75%','90%', 'max']
writer.writerow(header)
for rank in range(len(ordered_driver.keys())):
df = pd.read_csv('results/FlexDrivers/EVFlexSummary/'+ordered_driver.keys()[rank]+'_summary.csv')
writer.writerow([ordered_driver.keys()[rank],len(df['SessionLength']),df['SessionLength'].mean(),
df['SessionLength'].std(),df['SessionLength'].min(),np.percentile(df['SessionLength'],10),
np.percentile(df['SessionLength'],25),
np.percentile(df['SessionLength'],50),np.percentile(df['SessionLength'],75),
np.percentile(df['SessionLength'],90),df['SessionLength'].max()])
# stat summary of flexibility of all drivers
with open('results/FlexDrivers/'+'Flexibility_summary.csv','wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
header = ['driverid','count', 'mean','std','min', '10%','25%', '50%', '75%','90%', 'max']
writer.writerow(header)
for rank in range(len(ordered_driver.keys())):
df = pd.read_csv('results/FlexDrivers/EVFlexSummary/'+ordered_driver.keys()[rank]+'_summary.csv')
writer.writerow([ordered_driver.keys()[rank],len(df['Flexibility']),df['Flexibility'].mean(),
df['Flexibility'].std(),df['Flexibility'].min(),np.percentile(df['Flexibility'],10),
np.percentile(df['Flexibility'],25),
np.percentile(df['Flexibility'],50),np.percentile(df['Flexibility'],75),
np.percentile(df['Flexibility'],90),df['Flexibility'].max()])
Plot the distribution of each driver's average charging flexibility
In [205]:
from matplotlib.ticker import FuncFormatter
# plot all drivers' flexiblity
df = pd.read_csv('results/FlexDrivers/'+'Flexibility_summary.csv')
sns.set_context('poster')
fig, (axes) = plt.subplots(1,1,figsize=(10, 6), facecolor='w', edgecolor='k')
# fig.subplots_adjust(hspace = .1, wspace=.1)
# sns.distplot(df['mean'],color='m')
axes.set_ylabel('Charging Session Events')
axes.set_xlabel('Flexibility')
num_bins = 10
n, bins, patches = axes.hist(df['mean'], num_bins)
# To plot correct percentages in the y axis
to_percentage = lambda y, pos: str(round( ( y / float(len(df['mean'])) ) * 100.0, 1)) + '%'
axes.yaxis.set_major_formatter(FuncFormatter(to_percentage))
# ax1.set_xlim(0,1.1)
axes.set_ylabel('Probability')
axes.set_xlabel('Average Flexibility')
axes.set_title("Distribution of Drivers' Average Flexibility (Total Drivers: 143)")
fig.savefig('results/FlexDrivers/'+'AllFlexEV.png', dpi=300, format='png',bbox_inches='tight')
In [206]:
sns.set_context('poster')
fig, (axes) = plt.subplots(1,1,figsize=(10, 6), facecolor='w', edgecolor='k')
# fig.subplots_adjust(hspace = .1, wspace=.1)
num_bins = 10
n, bins, patches = axes.hist(df['count'], num_bins)
# To plot correct percentages in the y axis
to_percentage = lambda y, pos: str(round( ( y / float(len(df['count'])) ) * 100.0, 1)) + '%'
axes.yaxis.set_major_formatter(FuncFormatter(to_percentage))
# ax1.set_xlim(0,1.1)
axes.set_ylabel('Probability')
axes.set_xlabel('Number of Charging Sessions')
axes.set_title('Distribution of Charging Sessions (Total Sessions: '+str(df['count'].sum())+')')
fig.savefig('results/FlexDrivers/'+'EVChargingSessions.png', dpi=300, format='png',bbox_inches='tight')
In [8]:
df = pd.read_csv('results/FlexDrivers/2015EVFlexResults/'+'Flexibility_summary.csv')
df2 = df.ix[0:20,:].sort(['mean'])
top5id=df.ix[0:20,:].sort(['10%'],ascending=0)['driverid'][0:5]
fig, (axes) = plt.subplots(2,2,figsize=(18, 12), facecolor='w', edgecolor='k',sharex=True)
# fig.subplots_adjust(hspace = .1, wspace=.1)
axes[0,0].bar(range(len(df2['mean'])),df2['mean'])
axes[0,0].set_ylabel('Average Charging Flexibility')
axes[0,0].set_xlabel('# of Driver')
axes[0,0].set_title("Top 20 Drivers's Average Flexibility")
# axes[0].legend(df2.driverid)
axes[0,1].bar(range(len(df.ix[0:20,:].sort(['10%'])['10%'])),df.ix[0:20,:].sort(['10%'])['10%'],facecolor='green',alpha=0.5)
axes[0,1].set_ylabel('Charging Flexibility at 10th Percentile')
axes[0,1].set_xlabel('# of Driver')
axes[0,1].set_title("Top 20 Drivers's Charging Flexibility at 10th Percentile")
axes[1,0].bar(range(len(df.ix[0:20,:].sort(['25%'])['25%'])),df.ix[0:20,:].sort(['25%'])['25%'],facecolor='green',alpha=0.5)
axes[1,0].set_ylabel('Charging Flexibility at 25th Percentile')
axes[1,0].set_xlabel('# of Driver')
axes[1,0].set_title("Top 20 Drivers's Charging Flexibility at 25th Percentile")
axes[1,1].bar(range(len(df.ix[0:20,:].sort(['50%'])['50%'])),df.ix[0:20,:].sort(['50%'])['50%'],facecolor='green',alpha=0.5)
axes[1,1].set_ylabel('Charging Flexibility at 50th Percentile')
axes[1,1].set_xlabel('# of Driver')
axes[1,1].set_title("Top 20 Drivers's Charging Flexibility at 50th Percentile")
for i in range(len(top5id)):
axes[0,1].text(5,0.6-i*0.05,'Driver ID '+str(i+1)+': '+str(top5id.values[i]),fontsize=16,
bbox={'facecolor':'y', 'alpha':0.5})
fig.savefig('results/FlexDrivers/'+'BestFlexEV.png', dpi=300, format='png',bbox_inches='tight')
Top 5 Drivers' Charging Flexibility
In [6]:
top5id = [178085, 225969, 307497, 342601, 182981]
for i in range(5):
df = pd.read_csv('results/FlexDrivers/EVData/'+str(top5id[i])+'.csv')
Driver_Status=df.fillna(-1)
Driver_Status.loc[Driver_Status['power'] > 0.1,'power'] = 1
Driver_Status.loc[(Driver_Status['power'] >= 0) & (Driver_Status['power'] <= 0.1),'power'] = 0
data = Driver_Status.power.values.reshape(len(Driver_Status)/96,96)
data = data.astype(float)
sns.set_context('poster')
fig, (axes) = plt.subplots(1,1,figsize=(10, 6), facecolor='w', edgecolor='k')
# fig.subplots_adjust(hspace = .1, wspace=.1)
cmap = sns.cubehelix_palette(light=1, as_cmap=True)
axes.pcolor(data,cmap=cmap)
# sns.heatmap(data.T, annot=False, linewidths=.5, ax=axes[1])
majorLocator = MultipleLocator(8)
minorLocator = MultipleLocator(1)
axes.xaxis.set_major_locator(majorLocator)
axes.set_xticklabels(range(-2,26,2))
axes.set_xlim(0,96)
axes.set_ylim(0,len(data))
axes.set_ylabel('Charging Session Events')
axes.set_xlabel('Hour of Day')
axes.set_title('All Charging Sessions of #' + ' Driver '+str(top5id[i]))
axes.text(2, 140, "Charging", size=16, rotation=0.,color='white',
ha="left", va="center",
bbox=dict(boxstyle="round",
ec=(1.0, 0.5,0.5),
fc=(0.176,0.121,0.238),
)
)
axes.text(2, 120, "Plugged in not charging", size=16, rotation=0.,color='white',
ha="left", va="center",
bbox=dict(boxstyle="round",
ec=(1., 0.5, 0.5),
fc=(0.738,0.484,0.594),
)
)
fig.savefig('results/FlexDrivers/'+'FlexEV'+str(top5id[i])+'.png', dpi=300, format='png',bbox_inches='tight')
In [ ]: