def plot_saving_aggyear(df, timerange_pre,
timerange_post, theme, ax, cvrmse):
yearcol, timefilter = util.get_time_filter(timerange_post)
df['in_range'] = df[yearcol].map(timefilter)
df = df[df['in_range']]
if theme == 'eui_gas':
c1 = 'brown'
c2 = 'lightsalmon'
location = 'upper center'
wrapwidth = 30
else:
c1 = 'navy'
c2 = 'lightskyblue'
location = 'lower center'
wrapwidth = 99
energy = df.groupby(['month']).mean()
energy.reset_index(inplace=True)
x = np.array(energy['month'])
y = np.array(energy[theme])
y_hat = np.array(energy[theme + '_hat'])
save_percent = round((sum(y_hat) - sum(y)) / sum(y_hat) * 100, 1)
after = sum(y)
before = sum(y_hat)
line1, = ax.plot(x, y, c=c1, ls='-', lw=2, marker='o')
line2, = ax.plot(x, y_hat, c=c2, ls='-', lw=2, marker='o')
ax.fill_between(x, y, y_hat, where=y_hat >= y,
facecolor='lime', alpha=0.5, interpolate=True)
ax.fill_between(x, y, y_hat, where=y_hat < y, facecolor='red',
alpha=0.5, interpolate=True)
ax.legend([line1, line2],
['Actual {1} use in {0}'.format(timerange_post, lb.title_dict[theme]), '\n'.join(tw.wrap('{1} use given {2} habits but {0} weather'.format(timerange_post, lb.title_dict[theme], timerange_pre), wrapwidth))], loc=location)
def time_label(timerange):
if 'before' in timerange or 'after' in timerange:
return timerange[timerange.find(' ') + 1:]
else:
return timerange
if save_percent > 0:
ax.set_title('{2} after ({0}) vs before ({4}), {1}% less, CVRMSE: {3}'.format(time_label(timerange_post), abs(save_percent), lb.title_dict[theme], round(cvrmse, 2), time_label(timerange_pre)))
else:
ax.set_title('{2} after ({0}) vs before ({4}), {1}% more, CVRMSE: {3}'.format(time_label(timerange_post), abs(save_percent), lb.title_dict[theme], round(cvrmse, 2), time_label(timerange_pre)))
return save_percent, before, after
def plot_lean_saving_one(b, s, timerange):
yearcol, timefilter = util.get_time_filter(timerange)
df_gas = pd.read_csv('{0}dd_temp_eng/{1}_{2}_{3}.csv'.format(
weatherdir, 'HDD', b, s))
df_gas['timestamp'] = pd.to_datetime(df_gas['timestamp'])
df_gas['in_range'] = df_gas[yearcol].map(timefilter)
df_gas = df_gas[df_gas['in_range']]
if len(df_gas) == 0:
print 'no energy data: {0}, {1}, {2}'.format(b, s, timerange)
return
df_elec = pd.read_csv('{0}dd_temp_eng/{1}_{2}_{3}.csv'.format(
weatherdir, 'CDD', b, s))
df_elec['timestamp'] = pd.to_datetime(df_elec['timestamp'])
df_elec['in_range'] = df_elec[yearcol].map(timefilter)
df_elec = df_elec[df_elec['in_range']]
if len(df_elec) == 0:
print 'no elec data: {0}, {1}, {2}'.format(b, s, timerange)
return
slope_elec, intercept_elec, r_value_elec, p_value_elec, basetemp_elec = opt_lireg(
b, s, df_elec, 'CDD', 'eui_elec', timerange)
slope_gas, intercept_gas, r_value_gas, p_value_gas, basetemp_gas = opt_lireg(
b, s, df_gas, 'HDD', 'eui_gas', timerange)
d = {}
r2_elec = (r_value_elec)**2
r2_gas = (r_value_gas)**2
d['base_elec'] = intercept_elec
d['break_elec'] = basetemp_elec
d['slope_elec'] = slope_elec
d['base_gas'] = intercept_gas
d['break_gas'] = basetemp_gas
d['slope_gas'] = slope_elec
d['timerange'] = timerange
d['df_gas'] = df_gas
d['df_elec'] = df_elec
d['r2_gas'] = r2_gas
d['r2_elec'] = r2_elec
lean_one(b, s, slope_gas, slope_elec, intercept_gas, intercept_elec,
int(basetemp_gas[:-1]), int(basetemp_elec[:-1]), r2_gas, r2_elec,
timerange, 'eui_gas', 'eui_elec', 'combined')
return d
def plot_lean_saving_one(b, s, timerange):
yearcol, timefilter = util.get_time_filter(timerange)
df_gas = pd.read_csv('{0}dd_temp_eng/{1}_{2}_{3}.csv'.format(weatherdir, 'HDD', b, s))
df_gas['timestamp'] = pd.to_datetime(df_gas['timestamp'])
df_gas['in_range'] = df_gas[yearcol].map(timefilter)
df_gas = df_gas[df_gas['in_range']]
if len(df_gas) == 0:
print 'no energy data: {0}, {1}, {2}'.format(b, s, timerange)
return
df_elec = pd.read_csv('{0}dd_temp_eng/{1}_{2}_{3}.csv'.format(weatherdir, 'CDD', b, s))
df_elec['timestamp'] = pd.to_datetime(df_elec['timestamp'])
df_elec['in_range'] = df_elec[yearcol].map(timefilter)
df_elec = df_elec[df_elec['in_range']]
if len(df_elec) == 0:
print 'no elec data: {0}, {1}, {2}'.format(b, s, timerange)
return
slope_elec, intercept_elec, r_value_elec, p_value_elec, basetemp_elec = opt_lireg(b, s, df_elec, 'CDD', 'eui_elec', timerange)
slope_gas, intercept_gas, r_value_gas, p_value_gas, basetemp_gas = opt_lireg(b, s, df_gas, 'HDD', 'eui_gas', timerange)
d = {}
r2_elec = (r_value_elec) ** 2
r2_gas = (r_value_gas) ** 2
d['base_elec'] = intercept_elec
d['break_elec'] = basetemp_elec
d['slope_elec'] = slope_elec
d['base_gas'] = intercept_gas
d['break_gas'] = basetemp_gas
d['slope_gas'] = slope_elec
d['timerange'] = timerange
d['df_gas'] = df_gas
d['df_elec'] = df_elec
d['r2_gas'] = r2_gas
d['r2_elec'] = r2_elec
lean_one(b, s, slope_gas, slope_elec, intercept_gas,
intercept_elec, int(basetemp_gas[:-1]),
int(basetemp_elec[:-1]), r2_gas, r2_elec, timerange,
'eui_gas', 'eui_elec', 'combined')
return d
def piecewise_reg_one(b, s, n_par, theme, cuttail, timerange=None, *args):
sns.set_style("whitegrid")
sns.set_palette("Set2")
sns.set_context("paper", font_scale=1)
if len(args) == 0:
df = pd.read_csv(weatherdir + 'energy_temp/{0}_{1}.csv'.format(b, s))
else:
df = args[0]
df = df[df[s].notnull()]
if not 'year' in df:
df['year'] = df['timestamp'].map(lambda x: int(x[:4]))
if not 'month' in df:
df['month'] = df['timestamp'].map(lambda x: int(x[5:7]))
df['timestamp'] = pd.to_datetime(df['timestamp'])
df.sort('timestamp', inplace=True)
if timerange == None and cuttail:
df = df.tail(n=36)
elif timerange == None:
df = df
else:
yearcol, timefilter = util.get_time_filter(timerange)
df['in_range'] = df[yearcol].map(timefilter)
df = df[df['in_range']]
if len(df) > 36 and cuttail:
df = df.tail(n=36)
if len(df) < 6:
print 'not enough data points in {0}'.format(timerange)
return None
if 'day' in df:
df = df[['timestamp', 'year', 'month', s, theme, 'day']]
else:
df = df[['timestamp', 'year', 'month', s, theme]]
x = np.array(df[s])
y = np.array(df[theme])
x_min = x.min()
x_max = x.max()
break_low = 40
break_high = 81
xd = np.linspace(x_min, x_max, 150)
cvrmses = []
ps = []
slope_side = []
breakpoint_cal = []
if n_par == 2:
breakpoints = range(break_low, break_high)
for breakpoint in breakpoints:
def piecewise_linear_leftslope(x, k, intercept):
return np.piecewise(x, [x < breakpoint, x >= breakpoint], [lambda x:k * x + intercept, lambda x:k * breakpoint + intercept])
p1 , e1 = optimize.curve_fit(piecewise_linear_leftslope,
x, y)
cvrmse = CVRMSE(x, y, p1, piecewise_linear_leftslope,
n_par)
cvrmses.append(cvrmse)
ps.append(p1)
slope_side.append('left')
breakpoint_cal.append(breakpoint)
if theme == 'eui_elec':
def piecewise_linear_rightslope(x, k, intercept):
return np.piecewise(x, [x >= breakpoint, x < breakpoint], [lambda x:k * x + intercept, lambda x:k * breakpoint + intercept])
p2 , e2 = optimize.curve_fit(piecewise_linear_rightslope,
x, y)
cvrmse = CVRMSE(x, y, p2, piecewise_linear_rightslope,
n_par)
cvrmses.append(cvrmse)
ps.append(p2)
slope_side.append('right')
breakpoint_cal.append(breakpoint)
result = sorted(zip(breakpoint_cal, cvrmses, ps, slope_side), key=lambda x: x[1])
elif n_par == 3:
breakpoints = [(i, j) for i in range(break_low, break_high) for j in range(i + 1, break_high)]
for (break_1, break_2) in breakpoints:
def piecewise_linear(x, k1, b1, k2):
x0 = break_1
x1 = break_2
y0 = k1 * x0 + b1
y1 = y0
return np.piecewise(x, [x < x0, x >= x1], [lambda x:k1 * x + b1, lambda x:k2 * (x - x1) + y1, lambda x:y0])
p , e = optimize.curve_fit(piecewise_linear, x, y)
cvrmse = CVRMSE(x, y, p, piecewise_linear, n_par)
cvrmses.append(cvrmse)
ps.append(p)
slope_side.append('NA')
result = sorted(zip(breakpoints, cvrmses, ps, slope_side), key=lambda x: x[1])
best = result[0]
b_point_opt = best[0]
p_opt = best[2]
slope_side_opt = best[3]
cvrmse_opt = best[1]
# print theme, slope_side_opt, p_opt
# print 'breakpoint: {1}, error: {0}'.format(cvrmse_opt, b_point_opt)
if n_par == 2:
if slope_side_opt == 'left':
def piecewise_linear(x, k, intercept):
return np.piecewise(x, [x < b_point_opt, x >= b_point_opt], [lambda x:k * x + intercept, lambda x:k * b_point_opt + intercept])
else:
assert(slope_side_opt == 'right')
def piecewise_linear(x, k, intercept):
return np.piecewise(x, [x >= b_point_opt, x < b_point_opt], [lambda x:k * x + intercept, lambda x:k * b_point_opt + intercept])
elif n_par == 3:
def piecewise_linear(x, k1, b1, k2):
x0 = b_point_opt[0]
x1 = b_point_opt[1]
y0 = k1 * x0 + b1
y1 = y0
return np.piecewise(x, [x < x0, x >= x1], [lambda x:k1 * x + b1, lambda x:k2 * (x - x1) + y1, lambda x:y0])
if abs(p_opt[0] - 0) < 1e-20:
print 'all zero {0} consumption: {1}'.format(theme, p_opt)
good_regression = False
return None
# bx = plt.axes()
# bx.plot(x, y, "o")
# g = sns.lmplot(x=s, y=theme, hue='day', data=df, fit_reg=False)
# # print piecewise_linear(xd, *p_opt)
# plt.ylabel('kBtu')
# # plt.gca().set_ylim(bottom=0)
# ax = g.axes
# ax[0, 0].set_ylim((0, 1e5))
# P.savefig('{3}scatter_{0}_{1}_{2}.png'.format(b, s, theme, image_output_dir), dpi = 150)
# # plt.show()
# plt.close()
# g = sns.lmplot(x=s, y=theme, col='day', hue='day', col_wrap=3, size=3, data=df, fit_reg=False)
# ax = g.axes
# for i in ax:
# i.set_ylim((0, 1e5))
# P.savefig('{3}scatter_{0}_{1}_{2}_3b3.png'.format(b, s, theme, image_output_dir), dpi = 150)
# plt.close()
# plt.plot(x, y, "o")
# plt.plot(xd, piecewise_linear(xd, *p_opt))
# plt.title('break point {0}F, CV(RMSE): {1}'.format(b_point_opt, cvrmse_opt))
# plt.show()
# P.savefig('{3}regression_{0}_{1}_{2}.png'.format(b, s, theme, image_output_dir), dpi = 150)
# plt.close()
good_regression = True
# remove electric heating
if theme == 'eui_elec':
if slope_side_opt == 'left':
print 'bad electric regression left side -----------------'
good_regression = False
if slope_side_opt == 'right' and p_opt[0] < 0:
print 'bad electric regression right side ----------------'
good_regression = False
if theme == 'eui_gas':
if slope_side_opt == 'left' and p_opt[0] > 0:
print 'bad gas regression left side ----------------------'
good_regression = False
if slope_side_opt == 'right' > 0:
print 'bad gas regression right side ---------------------'
good_regression = False
return {'breakpoint': b_point_opt, 'CV(RMSE)': best[1],
'regression_par': p_opt, 'x_range': (x_min, x_max), 'fun':
piecewise_linear, 'x': x, 'y': y, 'good_regression':
good_regression, 'df': df}
def plot_saving_aggyear(df, timerange_pre, timerange_post, theme, ax, cvrmse):
yearcol, timefilter = util.get_time_filter(timerange_post)
df['in_range'] = df[yearcol].map(timefilter)
df = df[df['in_range']]
if theme == 'eui_gas':
c1 = 'brown'
c2 = 'lightsalmon'
location = 'upper center'
wrapwidth = 30
else:
c1 = 'navy'
c2 = 'lightskyblue'
location = 'lower center'
wrapwidth = 99
energy = df.groupby(['month']).mean()
energy.reset_index(inplace=True)
x = np.array(energy['month'])
y = np.array(energy[theme])
y_hat = np.array(energy[theme + '_hat'])
save_percent = round((sum(y_hat) - sum(y)) / sum(y_hat) * 100, 1)
after = sum(y)
before = sum(y_hat)
print save_percent, after, before, '################'
line1, = ax.plot(x, y, c=c1, ls='-', lw=2, marker='o')
line2, = ax.plot(x, y_hat, c=c2, ls='-', lw=2, marker='o')
ax.fill_between(x,
y,
y_hat,
where=y_hat >= y,
facecolor='lime',
alpha=0.5,
interpolate=True)
ax.fill_between(x,
y,
y_hat,
where=y_hat < y,
facecolor='red',
alpha=0.5,
interpolate=True)
ax.legend([line1, line2], [
'Actual {1} use in {0}'.format(timerange_post, lb.title_dict[theme]),
'\n'.join(
tw.wrap(
'{1} use given {2} habits but {0} weather'.format(
timerange_post, lb.title_dict[theme], timerange_pre),
wrapwidth))
],
loc=location)
def time_label(timerange):
if 'before' in timerange or 'after' in timerange:
return timerange[timerange.find(' ') + 1:]
else:
return timerange
if save_percent > 0:
ax.set_title(
'{2} after ({0}) vs before ({4}), {1}% less, CVRMSE: {3}'.format(
time_label(timerange_post), abs(save_percent),
lb.title_dict[theme], round(cvrmse, 2),
time_label(timerange_pre)))
else:
ax.set_title(
'{2} after ({0}) vs before ({4}), {1}% more, CVRMSE: {3}'.format(
time_label(timerange_post), abs(save_percent),
lb.title_dict[theme], round(cvrmse, 2),
time_label(timerange_pre)))
return save_percent, before, after
def lean_one(b, s, k_hdd, k_cdd, base_gas, base_elec, t_base_hdd,
t_base_cdd, r2_hdd, r2_cdd, timerange, theme_h, theme_c,
side):
y_upperlim = 15
x_leftlim = 40
x_rightlim = 85
if side == 'combined':
base_elec = max(base_elec, 0)
base_gas = max(base_gas, 0)
elif side == 'heating':
base_elec = 0
elif side == 'cooling':
base_gas = 0
df_hdd = pd.read_csv(weatherdir +
'dd_temp_eng/HDD_{0}_{1}.csv'.format(b, s))
df_cdd = pd.read_csv(weatherdir +
'dd_temp_eng/CDD_{0}_{1}.csv'.format(b, s))
yearcol, timefilter = util.get_time_filter(timerange)
hdd_base_header = '{0}F'.format(t_base_hdd)
cdd_base_header = '{0}F'.format(t_base_cdd)
df_hdd = df_hdd[['year', 'month', 'timestamp', theme_h, s,
hdd_base_header]]
df_cdd = df_cdd[['year', 'month', 'timestamp', theme_c,
cdd_base_header]]
df_hdd['timestamp'] = pd.to_datetime(df_hdd['timestamp'])
df_hdd['in_range'] = df_hdd[yearcol].map(timefilter)
df_hdd = df_hdd[df_hdd['in_range']]
df_cdd['timestamp'] = pd.to_datetime(df_cdd['timestamp'])
df_cdd['in_range'] = df_cdd[yearcol].map(timefilter)
df_cdd = df_cdd[df_cdd['in_range']]
df_hdd['cvt_temp_hdd'] = df_hdd[hdd_base_header].map(lambda x: dd2temp(x, t_base_hdd, 'HDD'))
df_cdd['cvt_temp_cdd'] = df_cdd[cdd_base_header].map(lambda x: dd2temp(x, t_base_cdd, 'CDD'))
df_hdd.rename(columns={hdd_base_header: hdd_base_header + '_HDD'},
inplace=True)
df_cdd.rename(columns={cdd_base_header: cdd_base_header + '_CDD'},
inplace=True)
df_plot = pd.merge(df_hdd, df_cdd, on=['year', 'month'],
how='inner')
df_plot[theme_h + '_hat'] = df_plot[hdd_base_header + '_HDD'].map(lambda x: k_hdd * x + base_gas)
df_plot[theme_c + '_hat'] = df_plot[cdd_base_header + '_CDD'].map(lambda x: k_cdd * x + base_elec)
df_plot[theme_h + '_offset'] = \
df_plot.apply(lambda r: r[theme_h] + base_elec if
r['cvt_temp_hdd'] < t_base_hdd else np.nan,
axis=1)
df_plot[theme_c + '_offset'] = \
df_plot.apply(lambda r: r[theme_c] + base_gas if
r['cvt_temp_cdd'] > t_base_cdd else np.nan,
axis=1)
df_plot[theme_h + '_hat_offset'] = \
df_plot.apply(lambda r: r[theme_h + '_hat'] + base_elec if
r['cvt_temp_hdd'] < t_base_hdd else np.nan,
axis=1)
df_plot[theme_c + '_hat_offset'] = \
df_plot.apply(lambda r: r[theme_c + '_hat'] + base_gas if
r['cvt_temp_cdd'] > t_base_cdd else np.nan,
axis=1)
sns.set_style("whitegrid")
sns.set_palette("Set2")
sns.set_context("paper", font_scale=1)
bx = plt.axes()
x1 = df_plot['cvt_temp_hdd']
y1 = df_plot[theme_h + '_offset']
y1_hat = df_plot[theme_h + '_hat_offset']
sorted_x1y1hat = sorted(zip(x1, y1_hat), key=lambda x: x[0])
sorted_x1 = [p[0] for p in sorted_x1y1hat]
sorted_y1_hat = [p[1] for p in sorted_x1y1hat]
x2 = df_plot['cvt_temp_cdd']
y2 = df_plot[theme_c + '_offset']
y2_hat = df_plot[theme_c + '_hat_offset']
sorted_x2y2hat = sorted(zip(x2, y2_hat), key=lambda x: x[0])
sorted_x2 = [p[0] for p in sorted_x2y2hat]
sorted_y2_hat = [p[1] for p in sorted_x2y2hat]
if side == 'heating':
xmin = x1.min()
xmax = x1.max()
elif side == 'cooling':
xmin = x2.min()
xmax = x2.max()
else:
xmin = min(x1.min(), x2.min())
xmax = max(x1.max(), x2.max())
gas_line_color = '#DE4A50'
gas_mk_color = '#DE4A50'
elec_line_color = '#429CD5'
elec_mk_color = '#429CD5'
base_gas_color = 'orange'
base_elec_color = 'yellow'
base_elec_text_color = 'goldenrod'
marker_size = 3
marker_style = 'o'
alpha = 0.5
font_family = 'sans-serif'
heating_note_color = '#A02225'
cooling_note_color = '#4D7FBC'
plt.figure(figsize=(5, 5), dpi=300, facecolor='w', edgecolor='k')
bx = plt.axes()
if side == 'heating' or side == 'combined':
plt.plot(x1, y1, marker_style, markerfacecolor=gas_mk_color, ms=marker_size)
# bx.annotate('HEATING', xy = (xmin + 1, base_elec + base_gas + \
# 0.2), fontsize=8,
# color=heating_note_color,
# weight='semibold',
# family=font_family)
plt.plot(sorted_x1, sorted_y1_hat, '-', color=gas_line_color)
bx.fill_between(sorted_x1, base_elec + base_gas, sorted_y1_hat, facecolor=gas_line_color, alpha=alpha)
if side == 'cooling' or side == 'combined':
plt.plot(x2, y2, marker_style, markerfacecolor=elec_mk_color, ms=marker_size)
# bx.annotate('COOLING', xy = (xmax - 9, (base_elec + base_gas)
# + 0.2), fontsize=8,
# color=cooling_note_color,
# weight='semibold',
# family=font_family)
plt.plot(sorted_x2, sorted_y2_hat, '-', color=elec_line_color)
bx.fill_between(sorted_x2, base_elec + base_gas, sorted_y2_hat, facecolor=elec_line_color, alpha=alpha)
# bx.annotate('BASE ELECTRIC', xy = ((xmin + xmax)/2 - 8,
# base_elec/2), fontsize=8,
# color=base_elec_text_color,
# weight='semibold',
# family=font_family)
plt.plot([xmin, xmax], [base_elec] * 2, color=base_elec_color)
bx.fill_between([xmin, xmax], 0, [base_elec] * 2, facecolor=base_elec_color, alpha=alpha)
plt.plot([xmin, xmax], [base_elec + base_gas] * 2, color=base_gas_color)
bx.fill_between([xmin, xmax], base_elec, [base_elec + base_gas] * 2, facecolor=base_gas_color, alpha=alpha)
print (round(r2_hdd, 2), round(r2_cdd, 2))
if side == 'heating':
plt.title('Building {0}, {1}\nHDD base {2}F ({4}{3})'.format(b, timerange, t_base_hdd, round(r2_hdd, 2), r'$R^2=$'))
elif side == 'cooling':
plt.title('Building {0}, {1}\nCDD base {2}F ({4}{3})'.format(b, timerange, t_base_cdd, round(r2_cdd, 2), r'$R^2=$'))
else:
plt.title('Building {0}, {1}\nHDD base {2}F ({6}{4}), CDD base {3}F({6}{5})'.format(b, timerange, t_base_hdd, t_base_cdd, round(r2_hdd, 2), round(r2_cdd, 2), r'$R^2=$'))
plt.xlabel('Temperature Represented Degree Day [F]')
plt.ylabel('Monthly [kBtu/sq.ft.]')
plt.ylim((0, y_upperlim))
plt.xlim((x_leftlim, x_rightlim))
P.savefig(os.getcwd() + '/plot_FY_weather/html/single_building/lean_dd/{0}_{1}_{2}.png'.format(b, s, timerange, side), dpi = 150)
plt.close()
return (xmin, xmax, y1.max(), y2.max())
def lean_one(b, s, k_hdd, k_cdd, base_gas, base_elec, t_base_hdd, t_base_cdd,
r2_hdd, r2_cdd, timerange, theme_h, theme_c, side):
y_upperlim = 15
x_leftlim = 40
x_rightlim = 85
if side == 'combined':
base_elec = max(base_elec, 0)
base_gas = max(base_gas, 0)
elif side == 'heating':
base_elec = 0
elif side == 'cooling':
base_gas = 0
df_hdd = pd.read_csv(weatherdir +
'dd_temp_eng/HDD_{0}_{1}.csv'.format(b, s))
df_cdd = pd.read_csv(weatherdir +
'dd_temp_eng/CDD_{0}_{1}.csv'.format(b, s))
yearcol, timefilter = util.get_time_filter(timerange)
hdd_base_header = '{0}F'.format(t_base_hdd)
cdd_base_header = '{0}F'.format(t_base_cdd)
df_hdd = df_hdd[[
'year', 'month', 'timestamp', theme_h, s, hdd_base_header
]]
df_cdd = df_cdd[['year', 'month', 'timestamp', theme_c, cdd_base_header]]
df_hdd['timestamp'] = pd.to_datetime(df_hdd['timestamp'])
df_hdd['in_range'] = df_hdd[yearcol].map(timefilter)
df_hdd = df_hdd[df_hdd['in_range']]
df_cdd['timestamp'] = pd.to_datetime(df_cdd['timestamp'])
df_cdd['in_range'] = df_cdd[yearcol].map(timefilter)
df_cdd = df_cdd[df_cdd['in_range']]
df_hdd['cvt_temp_hdd'] = df_hdd[hdd_base_header].map(
lambda x: dd2temp(x, t_base_hdd, 'HDD'))
df_cdd['cvt_temp_cdd'] = df_cdd[cdd_base_header].map(
lambda x: dd2temp(x, t_base_cdd, 'CDD'))
df_hdd.rename(columns={hdd_base_header: hdd_base_header + '_HDD'},
inplace=True)
df_cdd.rename(columns={cdd_base_header: cdd_base_header + '_CDD'},
inplace=True)
df_plot = pd.merge(df_hdd, df_cdd, on=['year', 'month'], how='inner')
df_plot[theme_h +
'_hat'] = df_plot[hdd_base_header +
'_HDD'].map(lambda x: k_hdd * x + base_gas)
df_plot[theme_c +
'_hat'] = df_plot[cdd_base_header +
'_CDD'].map(lambda x: k_cdd * x + base_elec)
df_plot[theme_h + '_offset'] = \
df_plot.apply(lambda r: r[theme_h] + base_elec if
r['cvt_temp_hdd'] < t_base_hdd else np.nan,
axis=1)
df_plot[theme_c + '_offset'] = \
df_plot.apply(lambda r: r[theme_c] + base_gas if
r['cvt_temp_cdd'] > t_base_cdd else np.nan,
axis=1)
df_plot[theme_h + '_hat_offset'] = \
df_plot.apply(lambda r: r[theme_h + '_hat'] + base_elec if
r['cvt_temp_hdd'] < t_base_hdd else np.nan,
axis=1)
df_plot[theme_c + '_hat_offset'] = \
df_plot.apply(lambda r: r[theme_c + '_hat'] + base_gas if
r['cvt_temp_cdd'] > t_base_cdd else np.nan,
axis=1)
sns.set_style("whitegrid")
sns.set_palette("Set2")
sns.set_context("paper", font_scale=1)
bx = plt.axes()
x1 = df_plot['cvt_temp_hdd']
y1 = df_plot[theme_h + '_offset']
y1_hat = df_plot[theme_h + '_hat_offset']
sorted_x1y1hat = sorted(zip(x1, y1_hat), key=lambda x: x[0])
sorted_x1 = [p[0] for p in sorted_x1y1hat]
sorted_y1_hat = [p[1] for p in sorted_x1y1hat]
x2 = df_plot['cvt_temp_cdd']
y2 = df_plot[theme_c + '_offset']
y2_hat = df_plot[theme_c + '_hat_offset']
sorted_x2y2hat = sorted(zip(x2, y2_hat), key=lambda x: x[0])
sorted_x2 = [p[0] for p in sorted_x2y2hat]
sorted_y2_hat = [p[1] for p in sorted_x2y2hat]
if side == 'heating':
xmin = x1.min()
xmax = x1.max()
elif side == 'cooling':
xmin = x2.min()
xmax = x2.max()
else:
xmin = min(x1.min(), x2.min())
xmax = max(x1.max(), x2.max())
gas_line_color = '#DE4A50'
gas_mk_color = '#DE4A50'
elec_line_color = '#429CD5'
elec_mk_color = '#429CD5'
base_gas_color = 'orange'
base_elec_color = 'yellow'
base_elec_text_color = 'goldenrod'
marker_size = 3
marker_style = 'o'
alpha = 0.5
font_family = 'sans-serif'
heating_note_color = '#A02225'
cooling_note_color = '#4D7FBC'
plt.figure(figsize=(5, 5), dpi=300, facecolor='w', edgecolor='k')
bx = plt.axes()
if side == 'heating' or side == 'combined':
plt.plot(x1,
y1,
marker_style,
markerfacecolor=gas_mk_color,
ms=marker_size)
# bx.annotate('HEATING', xy = (xmin + 1, base_elec + base_gas + \
# 0.2), fontsize=8,
# color=heating_note_color,
# weight='semibold',
# family=font_family)
plt.plot(sorted_x1, sorted_y1_hat, '-', color=gas_line_color)
bx.fill_between(sorted_x1,
base_elec + base_gas,
sorted_y1_hat,
facecolor=gas_line_color,
alpha=alpha)
if side == 'cooling' or side == 'combined':
plt.plot(x2,
y2,
marker_style,
markerfacecolor=elec_mk_color,
ms=marker_size)
# bx.annotate('COOLING', xy = (xmax - 9, (base_elec + base_gas)
# + 0.2), fontsize=8,
# color=cooling_note_color,
# weight='semibold',
# family=font_family)
plt.plot(sorted_x2, sorted_y2_hat, '-', color=elec_line_color)
bx.fill_between(sorted_x2,
base_elec + base_gas,
sorted_y2_hat,
facecolor=elec_line_color,
alpha=alpha)
# bx.annotate('BASE ELECTRIC', xy = ((xmin + xmax)/2 - 8,
# base_elec/2), fontsize=8,
# color=base_elec_text_color,
# weight='semibold',
# family=font_family)
plt.plot([xmin, xmax], [base_elec] * 2, color=base_elec_color)
bx.fill_between([xmin, xmax],
0, [base_elec] * 2,
facecolor=base_elec_color,
alpha=alpha)
plt.plot([xmin, xmax], [base_elec + base_gas] * 2, color=base_gas_color)
bx.fill_between([xmin, xmax],
base_elec, [base_elec + base_gas] * 2,
facecolor=base_gas_color,
alpha=alpha)
print(round(r2_hdd, 2), round(r2_cdd, 2))
if side == 'heating':
plt.title('Building {0}, {1}\nHDD base {2}F ({4}{3})'.format(
b, timerange, t_base_hdd, round(r2_hdd, 2), r'$R^2=$'))
elif side == 'cooling':
plt.title('Building {0}, {1}\nCDD base {2}F ({4}{3})'.format(
b, timerange, t_base_cdd, round(r2_cdd, 2), r'$R^2=$'))
else:
plt.title(
'Building {0}, {1}\nHDD base {2}F ({6}{4}), CDD base {3}F({6}{5})'.
format(b, timerange, t_base_hdd, t_base_cdd, round(r2_hdd, 2),
round(r2_cdd, 2), r'$R^2=$'))
plt.xlabel('Temperature Represented Degree Day [F]')
plt.ylabel('Monthly [kBtu/sq.ft.]')
plt.ylim((0, y_upperlim))
plt.xlim((x_leftlim, x_rightlim))
P.savefig(
os.getcwd() +
'/plot_FY_weather/html/single_building/lean_dd/{0}_{1}_{2}.png'.format(
b, s, timerange, side),
dpi=150)
plt.close()
return (xmin, xmax, y1.max(), y2.max())
