def generated_consumption_history_pre_post_1(request):
model = TemperatureSensitivityModel(cooling=True,heating=True)
pre_params = {
"base_consumption": request.param[0][0],
"heating_slope": request.param[0][1],
"heating_reference_temperature": request.param[0][2],
"cooling_slope": request.param[0][3],
"cooling_reference_temperature": request.param[0][4]
}
post_params = {
"base_consumption": request.param[1][0],
"heating_slope": request.param[1][1],
"heating_reference_temperature": request.param[1][2],
"cooling_slope": request.param[1][3],
"cooling_reference_temperature": request.param[1][4]
}
start = datetime(2012,1,1)
retrofit = datetime(2013,6,15)
end = datetime(2014,12,31)
pre_periods = generate_periods(start,retrofit,jitter_intensity=0)
post_periods = generate_periods(retrofit,end,jitter_intensity=0)
pre_gen = ConsumptionGenerator("electricity", "kWh", "degF", model, pre_params)
post_gen = ConsumptionGenerator("electricity", "kWh", "degF", model, post_params)
pre_consumptions = pre_gen.generate(gsod_722880_2012_2014_weather_source(), pre_periods)
post_consumptions = post_gen.generate(gsod_722880_2012_2014_weather_source(), post_periods)
ch = ConsumptionHistory(pre_consumptions + post_consumptions)
return ch, model.param_dict_to_list(pre_params), model.param_dict_to_list(post_params), retrofit
def prism_outputs_1(request):
model = TemperatureSensitivityModel(cooling=True,heating=True)
params = {
"base_consumption": request.param[0][0],
"heating_slope": request.param[0][1],
"heating_reference_temperature": request.param[0][2],
"cooling_slope": request.param[0][3],
"cooling_reference_temperature": request.param[0][4]
}
start = datetime(2012,1,1)
end = datetime(2014,12,31)
retrofit_start_date = datetime(2013,6,1)
retrofit_completion_date = datetime(2013,8,1)
periods = generate_periods(start,end,jitter_intensity=0)
gen = ConsumptionGenerator("electricity", "kWh", request.param[4], model, params)
consumptions = gen.generate(gsod_722880_2012_2014_weather_source(), periods)
consumption_kWh_per_day = [c.kWh / c.timedelta.days for c in consumptions]
consumption_n_days = [p.timedelta.days for p in periods]
fixture = ConsumptionHistory(consumptions), model.param_dict_to_list(params), \
request.param[1], request.param[2], \
request.param[3], request.param[4], \
retrofit_start_date, retrofit_completion_date, \
request.param[5], request.param[6], \
request.param[7], request.param[8], \
request.param[9], request.param[10], \
consumption_kWh_per_day, consumption_kWh_per_day, \
consumption_n_days, \
request.param[11]
return fixture
def test_generate_periods():
uniform_periods = generate_periods(datetime(2012,1,1),datetime(2013,1,1),period_jitter=timedelta(days=0))
assert uniform_periods[0].start == datetime(2012,1,1)
assert uniform_periods[0].end == datetime(2012,1,31)
assert uniform_periods[11].start == datetime(2012,11,26)
assert uniform_periods[11].end == datetime(2012,12,26)
short_uniform_periods = generate_periods(datetime(2012,1,1),datetime(2013,1,1),period_length_mean=timedelta(days=1),period_jitter=timedelta(days=0))
assert short_uniform_periods[0].start == datetime(2012,1,1)
assert short_uniform_periods[0].end == datetime(2012,1,2)
assert short_uniform_periods[330].start == datetime(2012,11,26)
assert short_uniform_periods[330].end == datetime(2012,11,27)
jittery_periods = generate_periods(datetime(2012,1,1),datetime(2013,1,1))
for p in jittery_periods:
assert p.end - p.start < timedelta(days=34)
assert p.end - p.start > timedelta(days=26)
assert not all([p.end - p.start == timedelta(days=30) for p in jittery_periods])
def test_project_generator(gsod_722880_2012_2014_weather_source,tmy3_722880_weather_source):
electricity_model = TemperatureSensitivityModel(cooling=True,heating=True)
gas_model = TemperatureSensitivityModel(cooling=False,heating=True)
electricity_param_distributions = {
"cooling_slope": uniform(loc=1, scale=.5),
"heating_slope": uniform(loc=1, scale=.5),
"base_consumption": uniform(loc=5, scale=5),
"cooling_reference_temperature": uniform(loc=70, scale=5),
"heating_reference_temperature": uniform(loc=60, scale=5)}
electricity_param_delta_distributions = {
"cooling_slope": uniform(loc=-.2, scale=.3),
"heating_slope": uniform(loc=-.2, scale=.3),
"base_consumption": uniform(loc=-2, scale=3),
"cooling_reference_temperature": uniform(loc=0, scale=0),
"heating_reference_temperature": uniform(loc=0, scale=0)}
gas_param_distributions = {
"heating_slope": uniform(loc=1, scale=.5),
"base_consumption": uniform(loc=5, scale=5),
"heating_reference_temperature": uniform(loc=60, scale=5)}
gas_param_delta_distributions = {
"heating_slope": uniform(loc=-.2, scale=.3),
"base_consumption": uniform(loc=-2, scale=3),
"heating_reference_temperature": uniform(loc=0, scale=0)}
generator = ProjectGenerator(electricity_model, gas_model,
electricity_param_distributions,
electricity_param_delta_distributions,
gas_param_distributions,
gas_param_delta_distributions)
periods = generate_periods(datetime(2012,1,1),datetime(2013,1,1),period_jitter=timedelta(days=0))
retrofit_start_date = datetime(2012,4,1)
retrofit_completion_date = datetime(2012,5,1)
results = generator.generate(gsod_722880_2012_2014_weather_source,
tmy3_722880_weather_source, periods, periods,
retrofit_start_date, retrofit_completion_date,
electricity_noise=None,gas_noise=None)
elec_kwh = [c.to("kWh") for c in results["electricity_consumptions"]]
gas_therms = [c.to("therms") for c in results["natural_gas_consumptions"]]
assert results.get("electricity_estimated_savings") is not None
assert results.get("natural_gas_estimated_savings") is not None
assert results.get("electricity_pre_params") is not None
assert results.get("natural_gas_pre_params") is not None
assert results.get("electricity_post_params") is not None
assert results.get("natural_gas_post_params") is not None
assert len(elec_kwh) == 12
assert len(gas_therms) == 12
assert elec_kwh[0] > elec_kwh[5]
assert gas_therms[0] > gas_therms[5]
assert elec_kwh[0] < 700 # could probably lower this upper bound
assert gas_therms[0] < 700 # could probably lower this upper bound
def generated_consumption_history_with_annualized_usage_1(request):
model = TemperatureSensitivityModel(cooling=True,heating=True)
params = {
"base_consumption": request.param[0][0],
"heating_slope": request.param[0][1],
"heating_reference_temperature": request.param[0][2],
"cooling_slope": request.param[0][3],
"cooling_reference_temperature": request.param[0][4]
}
start = datetime(2012,1,1)
end = datetime(2014,12,31)
periods = generate_periods(start,end,jitter_intensity=0)
gen = ConsumptionGenerator("electricity", "kWh", "degF", model, params)
consumptions = gen.generate(gsod_722880_2012_2014_weather_source(), periods)
return ConsumptionHistory(consumptions), model.param_dict_to_list(params), request.param[1]
def generated_consumption_history_with_n_periods_cdd_1(request):
model = TemperatureSensitivityModel(cooling=True,heating=True)
params = {
"base_consumption": request.param[0][0],
"heating_slope": request.param[0][1],
"heating_reference_temperature": request.param[0][2],
"cooling_slope": request.param[0][3],
"cooling_reference_temperature": request.param[0][4]
}
start,end = request.param[1]
periods = generate_periods(start,end,jitter_intensity=0)
fuel_type = "electricity"
gen = ConsumptionGenerator(fuel_type, "kWh", "degF", model, params)
consumptions = gen.generate(gsod_722880_2012_2014_weather_source(), periods)
return ConsumptionHistory(consumptions), fuel_type, request.param[2], request.param[3], request.param[4 ]
def bpi_2400_1(request):
elec_params = {
"base_consumption": request.param[0][0],
"heating_slope": request.param[0][1],
"heating_reference_temperature": request.param[0][2],
"cooling_slope": request.param[0][3],
"cooling_reference_temperature": request.param[0][4]
}
gas_params = {
"base_consumption": request.param[1][0],
"heating_slope": request.param[1][1],
"heating_reference_temperature": request.param[1][2],
}
normal_cdd = request.param[2]
normal_hdd = request.param[3]
cvrmse_electricity = request.param[4]
cvrmse_natural_gas = request.param[5]
n_periods = request.param[6]
time_span = request.param[7]
total_cdd = request.param[8]
total_hdd = request.param[9]
temp_unit = request.param[10]
start = datetime(2012,1,1)
end = datetime(2014,12,31)
periods = generate_periods(start,end,jitter_intensity=0)
elec_model = TemperatureSensitivityModel(cooling=True,heating=True)
gas_model = TemperatureSensitivityModel(cooling=False,heating=True)
gen_elec = ConsumptionGenerator("electricity", "kWh", temp_unit, elec_model, elec_params)
gen_gas = ConsumptionGenerator("natural_gas", "therms", temp_unit, gas_model, gas_params)
elec_consumptions = gen_elec.generate(gsod_722880_2012_2014_weather_source(), periods)
gas_consumptions = gen_gas.generate(gsod_722880_2012_2014_weather_source(), periods)
ch = ConsumptionHistory(elec_consumptions + gas_consumptions)
elec_param_list = elec_model.param_dict_to_list(elec_params)
gas_param_list = gas_model.param_dict_to_list(gas_params)
average_daily_usages_elec = [c.kWh/c.timedelta.days for c in elec_consumptions]
average_daily_usages_gas = [c.therms/c.timedelta.days for c in gas_consumptions]
return ch, elec_param_list, gas_param_list, normal_cdd, normal_hdd, \
cvrmse_electricity, cvrmse_natural_gas, \
n_periods, time_span, total_cdd, total_hdd, temp_unit, \
average_daily_usages_elec, average_daily_usages_gas
def time_span_1(request):
model = TemperatureSensitivityModel(cooling=True,heating=True)
params = {
"base_consumption": request.param[0][0],
"heating_slope": request.param[0][1],
"heating_reference_temperature": request.param[0][2],
"cooling_slope": request.param[0][3],
"cooling_reference_temperature": request.param[0][4]
}
fuel_type = request.param[1]
start, end = request.param[2]
n_days = request.param[3]
periods = generate_periods(start,end,jitter_intensity=0)
gen = ConsumptionGenerator(fuel_type, "kWh", "degF", model, params)
consumptions = gen.generate(gsod_722880_2012_2014_weather_source(), periods)
param_list = model.param_dict_to_list(params)
return ConsumptionHistory(consumptions), fuel_type, n_days
electricity_param_distributions,electricity_param_delta_distributions,
gas_param_distributions,gas_param_delta_distributions)
start_date = datetime.strptime(args.start_date,"%Y-%m-%d")
n_days = (datetime.now() - start_date).days
if n_days < 30:
message = "start_date ({}) must be at least 30 days before today".format(start_date)
raise ValueError(message)
weather_source = GSODWeatherSource(args.weather_station,start_date.year,datetime.now().year)
weather_normal_source = TMY3WeatherSource(args.weather_station)
project_data = []
consumption_data = []
for _ in range(args.n_projects):
elec_periods = generate_periods(start_date,datetime.now())
gas_periods = generate_periods(start_date,datetime.now())
retrofit_start_date = start_date + timedelta(days=random.randint(0,n_days-30))
retrofit_completion_date = retrofit_start_date + timedelta(days=30)
electricity_noise = None
gas_noise = None
elec_consumption, gas_consumption, estimated_elec_savings,\
estimated_gas_savings = generator.generate(weather_source, weather_normal_source, elec_periods, gas_periods,
retrofit_start_date, retrofit_completion_date,
electricity_noise,gas_noise)
custom_id = uuid.uuid4()
p_data = {
