def test_load_sample_hourly():
meter_data, temperature_data, metadata = load_sample(
"il-electricity-cdd-hdd-hourly"
)
assert meter_data.shape == (19417, 1)
assert meter_data.index.freq == "H"
assert temperature_data.shape == (19417,)
assert temperature_data.index.freq == "H"
assert metadata == {
"annual_baseline_base_load": 2000.0,
"annual_baseline_cooling_load": 4000.0,
"annual_baseline_heating_load": 4000.0,
"annual_baseline_total_load": 10000,
"annual_reporting_base_load": 1800.0,
"annual_reporting_cooling_load": 3600.0,
"annual_reporting_heating_load": 3600.0,
"annual_reporting_total_load": 9000.0,
"baseline_cooling_balance_point": 65,
"baseline_heating_balance_point": 60,
"blackout_end_date": datetime.datetime(2017, 1, 4, 0, 0, tzinfo=pytz.UTC),
"blackout_start_date": datetime.datetime(2016, 12, 26, 0, 0, tzinfo=pytz.UTC),
"freq": "hourly",
"id": "il-electricity-cdd-hdd-hourly",
"interpretation": "electricity",
"meter_data_filename": "il-electricity-cdd-hdd-hourly.csv.gz",
"reporting_cooling_balance_point": 65,
"reporting_heating_balance_point": 60,
"temperature_filename": "il-tempF.csv.gz",
"unit": "kWh",
"usaf_id": "724390",
}
def test_load_sample_daily():
meter_data, temperature_data, metadata = load_sample("il-electricity-cdd-hdd-daily")
assert meter_data.shape == (810, 1)
assert meter_data.index.freq == "D"
assert temperature_data.shape == (19417,)
assert temperature_data.index.freq == "H"
assert metadata is not None
def _from_sample(sample):
meter_data, temperature_data, metadata = load_sample(sample)
return {
"meter_data": meter_data,
"temperature_data": temperature_data,
"blackout_start_date": metadata["blackout_start_date"],
"blackout_end_date": metadata["blackout_end_date"],
}
def test_load_sample_billing_monthly():
meter_data, temperature_data, metadata = load_sample(
"il-electricity-cdd-hdd-billing_monthly")
assert meter_data.shape == (27, 1)
assert meter_data.index.freq is None
assert temperature_data.shape == (19417, )
assert temperature_data.index.freq == "H"
assert metadata is not None
def test_json_daily():
meter_data, temperature_data, sample_metadata = (
eemeter.load_sample("il-electricity-cdd-hdd-daily"))
blackout_start_date = sample_metadata["blackout_start_date"]
blackout_end_date = sample_metadata["blackout_end_date"]
# get meter data suitable for fitting a baseline model
baseline_meter_data, warnings = eemeter.get_baseline_data(
meter_data, end=blackout_start_date, max_days=365)
# create a design matrix (the input to the model fitting step)
baseline_design_matrix = eemeter.create_caltrack_daily_design_matrix(
baseline_meter_data,
temperature_data,
)
# build a CalTRACK model
baseline_model = eemeter.fit_caltrack_usage_per_day_model(
baseline_design_matrix, )
# get a year of reporting period data
reporting_meter_data, warnings = eemeter.get_reporting_data(
meter_data, start=blackout_end_date, max_days=365)
# compute metered savings
metered_savings_dataframe, error_bands = eemeter.metered_savings(
baseline_model,
reporting_meter_data,
temperature_data,
with_disaggregated=True)
# total metered savings
total_metered_savings = metered_savings_dataframe.metered_savings.sum()
# test JSON
json_str = json.dumps(baseline_model.json())
m = eemeter.CalTRACKUsagePerDayModelResults.from_json(json.loads(json_str))
# compute metered savings from the loaded model
metered_savings_dataframe, error_bands = eemeter.metered_savings(
m, reporting_meter_data, temperature_data, with_disaggregated=True)
# total metered savings
total_metered_savings_2 = metered_savings_dataframe.metered_savings.sum()
assert total_metered_savings == total_metered_savings_2
def test_load_sample_unknown():
with pytest.raises(ValueError):
load_sample("unknown")
def setup_demo_sample_models(site_id,
meter_id=None,
description=None,
calc_savings=False):
# this create a test sample meter with both hourly and daily model
# using sample meter and temperature data for the given site id
# use the hourly sample data
meter_data, temperature_data, sample_metadata = (
eemeter.load_sample("il-electricity-cdd-hdd-hourly"))
source = 'eemeter_sample'
# throw an exception is Site is not found
try:
site = SiteView.objects.get(object_id=site_id)
except SiteView.DoesNotExist:
site = SiteView.objects.get(entity_id=site_id)
min_datetime = None
max_datetime = None
yesterday = date.today() - timedelta(days=1)
# create a dummy weather station for the sample data if it did not alredy exist
try:
ws = WeatherStation.objects.get(weather_station_id='eemeter_ws')
except WeatherStation.DoesNotExist:
logger.info(
'setup_demo_sample_models: creating Sample WeatherStation eemeter_ws ...'
)
ws = WeatherStation.objects.create(weather_station_id='eemeter_ws',
station_name='Sample Station',
source=source,
elevation_uom_id='length_m')
# associate it to the site
SiteWeatherStations.objects.create(weather_station=ws,
site_id=site.entity_id,
source=source)
WeatherHistory.objects.filter(weather_station=ws).delete()
logger.info(
'setup_demo_sample_models: adding Sample WeatherStation data ...')
temp_items = []
for d, t in temperature_data.iteritems():
item = {"d": d, "t": t}
temp_items.append(item)
ts = datetime(year=yesterday.year,
month=yesterday.month,
day=yesterday.day,
hour=23,
minute=0,
second=0,
microsecond=0,
tzinfo=pytz.UTC)
for item in reversed(temp_items):
item["d"] = ts
ts = ts - timedelta(minutes=60)
# load the temperature data, this is given in F
for item in temp_items:
tc = (item["t"] - 32.0) * 5 / 9
WeatherHistory.objects.create(weather_station=ws,
as_of_datetime=item["d"],
temp_f=item["t"],
temp_c=tc,
source=source)
if not min_datetime or item["d"] < min_datetime:
min_datetime = item["d"]
if not max_datetime or item["d"] > max_datetime:
max_datetime = item["d"]
if not meter_id:
meter_id = '{}-sample_meter'.format(site_id)
if not description:
description = 'Sample Meter'
# cleanup previous entries as needed
MeterHistory.objects.filter(meter_id=meter_id).delete()
MeterFinancialValue.objects.filter(meter_id=meter_id).delete()
FinancialTransaction.objects.filter(meter_id=meter_id).delete()
Meter.objects.filter(meter_id=meter_id).delete()
# create the meter
logger.info('setup_demo_sample_models: creating Sample Meter %s ...',
meter_id)
meter = Meter.objects.create(meter_id=meter_id,
site_id=site.entity_id,
description=description,
account_number='123456789',
utility_id='USA_EIA_11208',
weather_station_id='eemeter_ws')
# setup the meter data (note this is slightly different format than temps)
logger.info('setup_demo_sample_models: adding Sample Meter %s data ...',
meter_id)
meter_items = []
for d, v in meter_data.iterrows():
item = {"d": d, "v": v}
meter_items.append(item)
ts = datetime(year=yesterday.year,
month=yesterday.month,
day=yesterday.day,
hour=23,
minute=0,
second=0,
microsecond=0,
tzinfo=pytz.UTC)
for item in reversed(meter_items):
item["d"] = ts
ts = ts - timedelta(minutes=60)
for item in meter_items:
MeterHistory.objects.create(meter=meter,
as_of_datetime=item["d"],
value=item["v"].value,
uom_id='energy_kWh',
source=source)
if not min_datetime or item["d"] < min_datetime:
min_datetime = item["d"]
if not max_datetime or item["d"] > max_datetime:
max_datetime = item["d"]
baseline_end_date = min_datetime + timedelta(days=365)
if baseline_end_date > max_datetime:
baseline_end_date = max_datetime
# create both models
frequency = 'hourly'
data = read_meter_data(meter, freq=frequency, end=baseline_end_date)
model = get_model_for_freq(data, frequency)
baseline_model = save_model(model,
meter_id=meter.meter_id,
description='CalTrack Hourly Model',
data=data,
frequency=frequency,
from_datetime=data['start'],
thru_datetime=data['end'])
if calc_savings:
calc_meter_savings(meter_id, baseline_model.id, baseline_end_date,
max_datetime)
frequency = 'daily'
data = read_meter_data(meter, freq=frequency, end=baseline_end_date)
model = get_model_for_freq(data, frequency)
baseline_model = save_model(model,
meter_id=meter.meter_id,
description='CalTrack Daily Model',
data=data,
frequency=frequency,
from_datetime=data['start'],
thru_datetime=data['end'])
if calc_savings:
calc_meter_savings(meter_id, baseline_model.id, baseline_end_date,
max_datetime)
return site, meter, baseline_model
def get_hourly_sample_data():
meter_data, temperature_data, sample_metadata = (
eemeter.load_sample("il-electricity-cdd-hdd-hourly"))
return read_sample_data(meter_data, temperature_data, sample_metadata)
def test_json_hourly():
meter_data, temperature_data, sample_metadata = (
eemeter.load_sample("il-electricity-cdd-hdd-hourly"))
blackout_start_date = sample_metadata["blackout_start_date"]
blackout_end_date = sample_metadata["blackout_end_date"]
# get meter data suitable for fitting a baseline model
baseline_meter_data, warnings = eemeter.get_baseline_data(
meter_data, end=blackout_start_date, max_days=365)
# create a design matrix for occupancy and segmentation
preliminary_design_matrix = (
eemeter.create_caltrack_hourly_preliminary_design_matrix(
baseline_meter_data,
temperature_data,
))
# build 12 monthly models - each step from now on operates on each segment
segmentation = eemeter.segment_time_series(preliminary_design_matrix.index,
'three_month_weighted')
# assign an occupancy status to each hour of the week (0-167)
occupancy_lookup = eemeter.estimate_hour_of_week_occupancy(
preliminary_design_matrix,
segmentation=segmentation,
)
# assign temperatures to bins
temperature_bins = eemeter.fit_temperature_bins(
preliminary_design_matrix,
segmentation=segmentation,
)
# build a design matrix for each monthly segment
segmented_design_matrices = (
eemeter.create_caltrack_hourly_segmented_design_matrices(
preliminary_design_matrix,
segmentation,
occupancy_lookup,
temperature_bins,
))
# build a CalTRACK hourly model
baseline_model = eemeter.fit_caltrack_hourly_model(
segmented_design_matrices,
occupancy_lookup,
temperature_bins,
)
# get a year of reporting period data
reporting_meter_data, warnings = eemeter.get_reporting_data(
meter_data, start=blackout_end_date, max_days=365)
# compute metered savings
metered_savings_dataframe, error_bands = eemeter.metered_savings(
baseline_model,
reporting_meter_data,
temperature_data,
with_disaggregated=True)
# total metered savings
total_metered_savings = metered_savings_dataframe.metered_savings.sum()
# test JSON
json_str = json.dumps(baseline_model.json())
m = eemeter.CalTRACKHourlyModelResults.from_json(json.loads(json_str))
# compute metered savings from the loaded model
metered_savings_dataframe, error_bands = eemeter.metered_savings(
m, reporting_meter_data, temperature_data, with_disaggregated=True)
# total metered savings
total_metered_savings_2 = metered_savings_dataframe.metered_savings.sum()
assert total_metered_savings == total_metered_savings_2
