def find_best_annualized_usage_params(target_annualized_usage, model,
start_params, params_to_change, weather_normal_source, n_guesses=100):
best_params = start_params
meter = AnnualizedUsageMeter(model=model, temperature_unit_str=TEMPERATURE_UNIT_STR)
best_result = meter.evaluate_raw(model_params=best_params, weather_normal_source=weather_normal_source)
best_ann_usage = best_result["annualized_usage"][0]
for n in range(n_guesses):
resolution = abs((target_annualized_usage - best_ann_usage) / target_annualized_usage)
param_dict = best_params.to_dict()
for param_name,scale_factor in params_to_change:
current_value = param_dict[param_name]
current_value = norm.rvs(param_dict[param_name], resolution * scale_factor)
while current_value < 0:
current_value = norm.rvs(param_dict[param_name], resolution * scale_factor)
param_dict[param_name] = current_value
model_params = model.param_type(param_dict)
result = meter.evaluate_raw(model_params=model_params, weather_normal_source=weather_normal_source)
ann_usage = result["annualized_usage"][0]
if abs(target_annualized_usage - ann_usage) < abs(target_annualized_usage - best_ann_usage):
diff = abs(target_annualized_usage - best_ann_usage)
best_params = model_params
best_ann_usage = ann_usage
return best_params, best_ann_usage
def _generate_fuel_consumptions(self, weather_source,
weather_normal_source, period, model, param_dists,
param_delta_dists, noise, baseline_period, reporting_period,
fuel_type, consumption_unit_name, temperature_unit_name):
baseline_params = model.param_type([param.rvs() for param in param_dists.to_list()])
reporting_params = model.param_type([bl_param + param_delta.rvs()
for bl_param, param_delta in zip(baseline_params.to_list(), param_delta_dists.to_list())])
annualized_usage_meter = AnnualizedUsageMeter(temperature_unit_name,
model)
baseline_annualized_usage = annualized_usage_meter.evaluate_raw(
model_params=baseline_params,
weather_normal_source=weather_normal_source)["annualized_usage"]
reporting_annualized_usage = annualized_usage_meter.evaluate_raw(
model_params=reporting_params,
weather_normal_source=weather_normal_source)["annualized_usage"]
estimated_annualized_savings = baseline_annualized_usage - \
reporting_annualized_usage
baseline_generator = MonthlyBillingConsumptionGenerator(fuel_type,
consumption_unit_name, temperature_unit_name, model,
baseline_params)
reporting_generator = MonthlyBillingConsumptionGenerator(fuel_type,
consumption_unit_name, temperature_unit_name, model,
reporting_params)
datetimes = generate_monthly_billing_datetimes(period, dist=None)
baseline_consumption_data = baseline_generator.generate(
weather_source, datetimes, daily_noise_dist=noise)
reporting_consumption_data = reporting_generator.generate(
weather_source, datetimes, daily_noise_dist=noise)
baseline_data = baseline_consumption_data.data
reporting_data = reporting_consumption_data.data
periods = baseline_consumption_data.periods()
records = []
for bl_data, rp_data, period in zip(baseline_data, reporting_data,
periods):
if period in reporting_period:
val = rp_data
else:
val = bl_data
record = {"start": period.start, "end": period.end, "value": val}
records.append(record)
cd = ConsumptionData(records, fuel_type, consumption_unit_name,
record_type="arbitrary")
return cd, estimated_annualized_savings, baseline_params, \
reporting_params
def find_best_annualized_usage_params(target_annualized_usage,
model,
start_params,
params_to_change,
weather_normal_source,
n_guesses=100):
best_params = start_params
meter = AnnualizedUsageMeter(model=model,
temperature_unit_str=TEMPERATURE_UNIT_STR)
best_result = meter.evaluate_raw(
model_params=best_params, weather_normal_source=weather_normal_source)
best_ann_usage = best_result["annualized_usage"][0]
for n in range(n_guesses):
resolution = abs((target_annualized_usage - best_ann_usage) /
target_annualized_usage)
param_dict = best_params.to_dict()
for param_name, scale_factor in params_to_change:
current_value = param_dict[param_name]
current_value = norm.rvs(param_dict[param_name],
resolution * scale_factor)
while current_value < 0:
current_value = norm.rvs(param_dict[param_name],
resolution * scale_factor)
param_dict[param_name] = current_value
model_params = model.param_type(param_dict)
result = meter.evaluate_raw(
model_params=model_params,
weather_normal_source=weather_normal_source)
ann_usage = result["annualized_usage"][0]
if abs(target_annualized_usage -
ann_usage) < abs(target_annualized_usage - best_ann_usage):
diff = abs(target_annualized_usage - best_ann_usage)
best_params = model_params
best_ann_usage = ann_usage
return best_params, best_ann_usage
def runeemetermodel(meta, temp, building, model):
timezone = meta.T[building].timezone
start = meta.T[building].datastart
end = meta.T[building].dataend
building_data = pd.DataFrame(temp[building].tz_convert(timezone).truncate(before=start,after=end))
weatherDataSet_directory = "C:/Users/behzad/Dropbox/3 Research Projects/2 Data for Building/BuildingDataGenomeProject/the-building-data-genome-project/data/external/weather/"
weatherfilename = meta.T[building].newweatherfilename
weatherfile_path = weatherDataSet_directory+weatherfilename
weather = pd.read_csv(weatherfile_path,index_col='timestamp', parse_dates=True, na_values='-9999')
weather = weather.tz_localize(timezone, ambiguous = 'infer')
weatherdata = CustomDailyWeatherSource2(weather)
# df_t = pd.Series(weatherdata.data)
df_t = pd.Series(weatherdata.tempC)
df_t.index = df_t.index.to_datetime()
df_t = pd.DataFrame(df_t)
df_t.columns = ["TempC"]
to_load = building_data.resample('D').sum().tz_localize(None)
to_load.columns = ['Consumption']
to_load['StartDateTime'] = to_load.index.format('%Y-%m-%d %H:%M:%S.%f')[1:]
end=to_load.index+timedelta(days=1)
to_load['EndDateTime'] = end.format('%Y-%m-%d %H:%M:%S.%f')[1:]
to_load['UnitofMeasure'] = 'kWh'
to_load['FuelType'] = 'electricity'
to_load['ReadingType'] = 'actual'
to_load = to_load.reset_index(drop=True)
consumptions = import_pandas(to_load)
param_optimization_meter = TemperatureSensitivityParameterOptimizationMeter("degC",model)
annualized_usage_meter = AnnualizedUsageMeter("degC",model)
params = param_optimization_meter.evaluate_raw(
consumption_data=consumptions,
weather_source=weatherdata,
energy_unit_str="kWh")["temp_sensitivity_params"]
names1 = ['Baseload', 'HeatBalPtF', 'HeatSlope','CoolBalPtF','CoolSlope']
df_par = pd.DataFrame(params.to_list())
df_par['Parameter'] = index=names1
df_par.columns = ['Value', 'Parameter']
df_par = df_par.set_index('Parameter')
df_m = building_data.resample('D').sum().tz_localize(None).join(df_t.resample('1D').mean(), how='inner')
params_list = params.to_list()
df_m['model_Consumption'] = params_list[0] + params_list[2]*(np.where(df_m.TempC<params_list[1], params_list[1]-df_m.TempC, 0)) + params_list[4]*(np.where(df_m.TempC>params_list[3], df_m.TempC - params_list[3], 0))
df_m['modelbase'] = params_list[0]
df_m['modelheating'] = params_list[2]*(np.where(df_m.TempC<params_list[1], params_list[1]-df_m.TempC, np.nan))
df_m['modelcooling'] = params_list[4]*(np.where(df_m.TempC>params_list[3], df_m.TempC - params_list[3], np.nan))
df_par.loc['totalNMBE'] = 100*((df_m[building] - df_m.model_Consumption).sum()/((df_m[building].count()-1) * df_m[building].mean()))
df_par.loc['totalCVRMSE'] = 100*((((df_m[building] - df_m.model_Consumption)**2).sum()/(df_m[building].count()-1))**(0.5))/df_m[building].mean()
return df_m, df_par
def _generate_fuel_consumptions(self, weather_source, weather_normal_source, periods,
model, param_dists, param_delta_dists, noise,
retrofit_start_date, retrofit_completion_date,
fuel_type, consumption_unit_name, temperature_unit_name):
pre_params = {}
post_params = {}
for k,v in param_dists.items():
pre_params[k] = v.rvs()
post_params[k] = pre_params[k] + param_delta_dists[k].rvs()
annualized_usage_meter = AnnualizedUsageMeter(temperature_unit_name,model)
pre_annualized_usage = annualized_usage_meter.evaluate(
temp_sensitivity_params=model.param_dict_to_list(pre_params),
weather_normal_source=weather_normal_source)["annualized_usage"]
post_annualized_usage = annualized_usage_meter.evaluate(
temp_sensitivity_params=model.param_dict_to_list(post_params),
weather_normal_source=weather_normal_source)["annualized_usage"]
estimated_annualized_savings = pre_annualized_usage - post_annualized_usage
pre_generator = ConsumptionGenerator(fuel_type, consumption_unit_name,
temperature_unit_name, model, pre_params)
post_generator = ConsumptionGenerator(fuel_type, consumption_unit_name,
temperature_unit_name, model, post_params)
pre_consumptions = pre_generator.generate(weather_source, periods, noise)
post_consumptions = post_generator.generate(weather_source, periods, noise)
final_consumptions = []
for pre_c, post_c, period in zip(pre_consumptions,post_consumptions,periods):
pre_retrofit_completion = period.start < retrofit_completion_date
post_retrofit_start = period.end > retrofit_start_date
if not pre_retrofit_completion:
consumption = post_c
elif not post_retrofit_start:
consumption = pre_c
else:
usage = (pre_c.to(consumption_unit_name) + post_c.to(consumption_unit_name)) / 2
consumption = Consumption(usage,consumption_unit_name,fuel_type,period.start,period.end)
final_consumptions.append(consumption)
return final_consumptions, estimated_annualized_savings, pre_params, post_params
to_load['EndDateTime'] = end.format('%Y-%m-%d %H:%M:%S.%f')[1:]
to_load['UnitofMeasure'] = 'kWh'
to_load['FuelType'] = 'electricity'
to_load['ReadingType'] = 'actual'
to_load = to_load.reset_index(drop=True)
to_load.head()
consumptions = import_pandas(to_load)
param_optimization_meter = TemperatureSensitivityParameterOptimizationMeter("degC", model)
annualized_usage_meter = AnnualizedUsageMeter("degC", model)
params = param_optimization_meter.evaluate_raw(consumption_data=consumptions, weather_source=formattedWeatherData2,energy_unit_str="kWh")["temp_sensitivity_params"]
params_list = params.to_list()
names1 = ['Baseload', 'HeatBalPtF', 'HeatSlope','CoolBalPtF','CoolSlope']
df_par = pd.DataFrame(params.to_list())
df_par['Parameter'] = index=names1
df_par.columns = ['Value', 'Parameter']
df_par = df_par.set_index('Parameter')
df_m = ExtractedData_chosenBuilding.resample('D').sum().tz_localize(None).join(df_t.resample('1D').mean(), how='inner')
df_m.tail()
df_m['model_Consumption'] = params_list[0] + params_list[2]*(np.where(df_m.TempC<params_list[1], params_list[1]-df_m.TempC, 0)) + params_list[4]*(np.where(df_m.TempC>params_list[3], df_m.TempC - params_list[3], 0))
