def _create_eemeter_consumptions(consumption_data_rows):
"""
from consumption data rows create eemeter objects
"""
natural_gas_records = [{
"start": row.start,
"end": row.end,
"value": row.value
} for _, row in consumption_data_rows[consumption_data_rows.fuel_type ==
"natural_gas"].iterrows()]
electricity_records = [{
"start": row.start,
"end": row.end,
"value": row.value
} for _, row in consumption_data_rows[consumption_data_rows.fuel_type ==
"electricity"].iterrows()]
consumption = []
if len(natural_gas_records) > 0:
cd_g = ConsumptionData(natural_gas_records,
"natural_gas",
"therm",
record_type="arbitrary")
consumption.append(cd_g)
if len(electricity_records) > 0:
cd_e = ConsumptionData(electricity_records,
"electricity",
"kWh",
record_type="arbitrary")
consumption.append(cd_e)
return consumption
def generate_consumption_records(model, params_pre, params_post, datetimes_pre, datetimes_post, fuel_type, energy_unit, weather_source):
datetimes = datetimes_pre[:-1] + datetimes_post
records = [{"start": start, "end": end, "value": np.nan}
for start, end in zip(datetimes, datetimes[1:])]
cd = ConsumptionData(records, fuel_type, energy_unit, record_type="arbitrary")
periods = cd.periods()
periods_pre = periods[:len(datetimes_pre[:-1])]
periods_post = periods[len(datetimes_pre[:-1]):]
period_pre_daily_temps = weather_source.daily_temperatures(periods_pre, TEMPERATURE_UNIT_STR)
period_post_daily_temps = weather_source.daily_temperatures(periods_post, TEMPERATURE_UNIT_STR)
period_pre_average_daily_usages = model.transform(period_pre_daily_temps, params_pre)
period_post_average_daily_usages = model.transform(period_post_daily_temps, params_post)
daily_noise_dist = None
for average_daily_usage, period in zip(period_pre_average_daily_usages, periods_pre):
n_days = period.timedelta.days
if daily_noise_dist is not None:
average_daily_usage += np.mean(daily_noise_dist.rvs(n_days))
cd.data[period.start] = average_daily_usage * n_days
for average_daily_usage, period in zip(period_post_average_daily_usages, periods_post):
n_days = period.timedelta.days
if daily_noise_dist is not None:
average_daily_usage += np.mean(daily_noise_dist.rvs(n_days))
cd.data[period.start] = average_daily_usage * n_days
return cd
def test_downsample_hourly_frequency():
records = [{
"start":
datetime(2015, 1, 1, tzinfo=pytz.UTC) + timedelta(seconds=i * 900),
"value":
np.nan if i % 30 == 0 or 1000 < i < 2000 else 0.1,
"estimated":
i % 3 == 0 or 2000 < i < 3000,
} for i in range(10000)]
cd = ConsumptionData(records,
"electricity",
"kWh",
record_type="arbitrary_start")
cd_down = cd.downsample('H')
assert np.isnan(cd.data["2015-01-01 00:00:00"])
assert_allclose(cd.data["2015-01-01 00:15:00"], 0.1)
assert cd.data.shape == (10000, )
assert cd.estimated["2015-01-01 00:00:00"] == True
assert cd.estimated["2015-01-01 00:15:00"] == False
assert cd.estimated.shape == (10000, )
assert_allclose(cd_down.data["2015-01-01 00:00"], 0.3)
assert_allclose(cd_down.data["2015-01-01 01:00"], 0.4)
assert cd_down.data.shape == (2500, )
assert cd_down.estimated["2015-01-01 00:00"] == True
assert cd_down.estimated["2015-01-01 01:00"] == False
assert cd_down.estimated.shape == (2500, )
def test_recent_reading_meter():
recent_record = {
"start": datetime.now(pytz.utc) - timedelta(days=390),
"end": datetime.now(pytz.utc) - timedelta(days=360),
"value": 0
}
old_record = {
"start": datetime(2012, 1, 1, tzinfo=pytz.utc),
"end": datetime(2012, 2, 1, tzinfo=pytz.utc),
"value": 0
}
no_cd = ConsumptionData([], "electricity", "kWh", record_type="arbitrary")
old_cd = ConsumptionData([old_record],
"electricity",
"kWh",
record_type="arbitrary")
recent_cd = ConsumptionData([recent_record],
"electricity",
"kWh",
record_type="arbitrary")
mixed_cd = ConsumptionData([recent_record, old_record],
"electricity",
"kWh",
record_type="arbitrary")
meter = RecentReadingMeter()
assert meter.evaluate_raw(consumption_data=no_cd)["n_days"] == np.inf
assert meter.evaluate_raw(consumption_data=old_cd)["n_days"] == 31
assert meter.evaluate_raw(consumption_data=recent_cd)["n_days"] == 30
assert meter.evaluate_raw(consumption_data=mixed_cd)["n_days"] == 30
def generate(self, weather_source, datetimes, daily_noise_dist=None):
"""Returns a ConsumptionData instance given a particular weather
source and a list of datetimes.
Parameters
----------
weather_source : eemeter.weather.WeatherSourceBase
Weather source from which to draw outdoor temperature data.
datetimes : list of datetime objects
Periods over which to simulate consumption.
daily_noise_dist : scipy.stats.rv_continuous, default None
Noise to add to each day in a period. Noise is additive and sampled
independently for each period. e.g. scipy.stats.normal().
"""
records = [{"start": start, "end": end, "value": np.nan}
for start, end in zip(datetimes, datetimes[1:])]
cd = ConsumptionData(records, self.fuel_type,
self.consumption_unit_name, record_type="arbitrary")
periods = cd.periods()
period_daily_temps = weather_source.daily_temperatures(periods,
self.temperature_unit_name)
period_average_daily_usages = self.model.transform(period_daily_temps,self.params)
for average_daily_usage, period in zip(period_average_daily_usages,periods):
n_days = period.timedelta.days
if daily_noise_dist is not None:
average_daily_usage += np.mean(daily_noise_dist.rvs(n_days))
cd.data[period.start] = average_daily_usage * n_days
return cd
def test_consumption_data_arbitrary_end(records_arbitrary_end, fuel_type,
unit_name, record_type_arbitrary_end):
cd = ConsumptionData(records_arbitrary_end,
fuel_type,
unit_name,
record_type=record_type_arbitrary_end)
assert_allclose(cd.data.values, [0, 0, 0, 1, 0, np.nan],
rtol=RTOL,
atol=ATOL)
assert cd.data.index[0] == datetime(2014, 2, 2)
assert cd.data.index[5] == datetime(2015, 2, 1)
assert cd.freq is None
assert cd.freq_timedelta is None
assert cd.pulse_value is None
generated_records = cd.records(record_type=record_type_arbitrary_end)
assert len(generated_records) == 6
assert generated_records[0] == {
"end": datetime(2014, 2, 2),
"value": np.nan,
"estimated": False
}
assert generated_records[5] == {
"end": datetime(2015, 2, 1),
"value": 0,
"estimated": False
}
def test_consumption_data_pulse(records_pulse,
fuel_type, unit_name):
with pytest.raises(ValueError):
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse")
with pytest.raises(ValueError):
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse", pulse_value=0)
with pytest.raises(ValueError):
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse", pulse_value=-1)
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse", pulse_value=1)
assert cd.pulse_value == 1
assert_allclose(cd.data.values,[np.nan,1,1,1,1],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
assert cd.data.index[4] == datetime(2015,2,1)
assert cd.freq is None
assert cd.freq_timedelta is None
assert cd.pulse_value == 1
generated_records = cd.records(record_type="pulse")
sorted_records = sorted(records_pulse, key=lambda x: x["pulse"])
assert len(generated_records) == len(sorted_records)
for r1, r2 in zip(generated_records,sorted_records):
assert r1 == r2
def test_downsample_hourly_frequency():
records = [{
"start": datetime(2015, 1, 1, tzinfo=pytz.UTC) + timedelta(seconds=i*900),
"value": np.nan if i % 30 == 0 or 1000 < i < 2000 else 0.1,
"estimated": i % 3 == 0 or 2000 < i < 3000,
} for i in range(10000)]
cd = ConsumptionData(records, "electricity", "kWh", record_type="arbitrary_start")
cd_down = cd.downsample('H')
assert np.isnan(cd.data["2015-01-01 00:00:00"])
assert_allclose(cd.data["2015-01-01 00:15:00"], 0.1)
assert cd.data.shape == (10000,)
assert cd.estimated["2015-01-01 00:00:00"] == True
assert cd.estimated["2015-01-01 00:15:00"] == False
assert cd.estimated.shape == (10000,)
assert_allclose(cd_down.data["2015-01-01 00:00"], 0.3)
assert_allclose(cd_down.data["2015-01-01 01:00"], 0.4)
assert cd_down.data.shape == (2500,)
assert cd_down.estimated["2015-01-01 00:00"] == True
assert cd_down.estimated["2015-01-01 01:00"] == False
assert cd_down.estimated.shape == (2500,)
def evaluate_raw(self, consumption_data, **kwargs):
""" Creates a list of tagged ConsumptionData objects for each of this
project's fuel types in the baseline period and the reporting period.
Parameters
----------
project : eemeter.project.Project
Project instance from which to get consumption data.
Returns
-------
out : dict
- "fuel_types": list of tagged strings
"""
rng = pd.date_range('2011-01-01', periods=2, freq=self.freq)
max_period = rng[1] - rng[0]
index_series = pd.Series(consumption_data.data.index.tz_convert(pytz.UTC))
n = 5
if index_series.shape[0] > n:
timedeltas = (index_series - index_series.shift()).iloc[1:(n + 1)]
for timedelta in timedeltas:
if timedelta > max_period:
return { "consumption_resampled": consumption_data }
consumption_resampled = ConsumptionData([],
consumption_data.fuel_type, consumption_data.unit_name,
record_type="arbitrary")
consumption_resampled.data = consumption_data.data.resample(self.freq).sum()
return { "consumption_resampled": consumption_resampled }
def test_downsample_empty():
records = []
cd = ConsumptionData(records, "electricity", "kWh", record_type="arbitrary_start")
cd_down = cd.downsample('D')
assert_allclose(cd.data, cd_down.data)
assert_allclose(cd.estimated, cd_down.estimated)
def test_consumption_data_pulse(records_pulse,
fuel_type, unit_name):
with pytest.raises(ValueError):
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse")
with pytest.raises(ValueError):
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse", pulse_value=0)
with pytest.raises(ValueError):
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse", pulse_value=-1)
cd = ConsumptionData(records_pulse,
fuel_type, unit_name, record_type="pulse", pulse_value=1)
assert cd.pulse_value == 1
assert_allclose(cd.data.values,[np.nan,1,1,1,1],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
assert cd.data.index[4] == datetime(2015,2,1)
assert cd.freq is None
assert cd.freq_timedelta is None
assert cd.pulse_value == 1
generated_records = cd.records(record_type="pulse")
sorted_records = sorted(records_pulse, key=lambda x: x["pulse"])
assert len(generated_records) == len(sorted_records)
for r1, r2 in zip(generated_records,sorted_records):
assert r1 == r2
def test_consumption_data_empty_records(fuel_type, unit_name):
cd = ConsumptionData([], fuel_type, unit_name, freq="S")
assert_allclose(cd.data.values, [], rtol=RTOL, atol=ATOL)
cd = ConsumptionData([], fuel_type, unit_name, record_type="arbitrary")
assert_allclose(cd.data.values, [], rtol=RTOL, atol=ATOL)
cd = ConsumptionData([], fuel_type, unit_name, record_type="arbitrary_start")
assert_allclose(cd.data.values, [], rtol=RTOL, atol=ATOL)
cd = ConsumptionData([], fuel_type, unit_name, record_type="arbitrary_end")
assert_allclose(cd.data.values, [], rtol=RTOL, atol=ATOL)
cd = ConsumptionData([], fuel_type, unit_name, record_type="pulse", pulse_value=1)
assert_allclose(cd.data.values, [], rtol=RTOL, atol=ATOL)
def test_downsample_empty():
records = []
cd = ConsumptionData(records,
"electricity",
"kWh",
record_type="arbitrary_start")
cd_down = cd.downsample('D')
assert_allclose(cd.data, cd_down.data)
assert_allclose(cd.estimated, cd_down.estimated)
def test_downsample_two_day():
records = [{
"start": datetime(2015, 1, 1, tzinfo=pytz.UTC) + timedelta(days=2*i),
"value": 1.0,
"estimated": False,
} for i in range(100)]
cd = ConsumptionData(records, "electricity", "kWh", record_type="arbitrary_start")
cd_down = cd.downsample('D')
assert_allclose(cd.data, cd_down.data)
assert_allclose(cd.estimated, cd_down.estimated)
def test_downsample_single_record():
records = [{
"start": datetime(2015, 1, 1, tzinfo=pytz.UTC),
"value": 0,
"estimated": False
}]
cd = ConsumptionData(records, "electricity", "kWh", record_type="arbitrary_start")
cd_down = cd.downsample('D')
assert_allclose(cd.data, cd_down.data)
assert_allclose(cd.estimated, cd_down.estimated)
def generate_consumption_records(model, params_pre, params_post, datetimes_pre,
datetimes_post, fuel_type, energy_unit,
weather_source):
datetimes = datetimes_pre[:-1] + datetimes_post
records = [{
"start": start,
"end": end,
"value": np.nan
} for start, end in zip(datetimes, datetimes[1:])]
cd = ConsumptionData(records,
fuel_type,
energy_unit,
record_type="arbitrary")
periods = cd.periods()
periods_pre = periods[:len(datetimes_pre[:-1])]
periods_post = periods[len(datetimes_pre[:-1]):]
period_pre_daily_temps = weather_source.daily_temperatures(
periods_pre, TEMPERATURE_UNIT_STR)
period_post_daily_temps = weather_source.daily_temperatures(
periods_post, TEMPERATURE_UNIT_STR)
period_pre_average_daily_usages = model.transform(period_pre_daily_temps,
params_pre)
period_post_average_daily_usages = model.transform(period_post_daily_temps,
params_post)
daily_noise_dist = None
for average_daily_usage, period in zip(period_pre_average_daily_usages,
periods_pre):
n_days = period.timedelta.days
if daily_noise_dist is not None:
average_daily_usage += np.mean(daily_noise_dist.rvs(n_days))
cd.data[period.start] = average_daily_usage * n_days
for average_daily_usage, period in zip(period_post_average_daily_usages,
periods_post):
n_days = period.timedelta.days
if daily_noise_dist is not None:
average_daily_usage += np.mean(daily_noise_dist.rvs(n_days))
cd.data[period.start] = average_daily_usage * n_days
return cd
def _process_raw_consumption_records_data(records):
""" Turn records into "start" oriented records, make UTC. """
# assume all from the same project and fuel_type
if len(records) > 0:
project_id = records[0]["project_id"]
fuel_type = records[0]["fuel_type"]
# dumb hack - the fuel_type and unit_name are actually just placeholders
# and don't actually affect the processing. This an indication that (TODO),
# this logic should be factored out of the ConsumptionData object.
consumption_data = ConsumptionData(records, "electricity", "kWh",
record_type="arbitrary")
consumption_records_data = []
for (d1, value), (d2, estimated) in zip(consumption_data.data.iteritems(), consumption_data.estimated.iteritems()):
assert d1 == d2
record = {
"start": pytz.UTC.localize(d1.to_datetime()).strftime("%Y-%m-%dT%H:%M:%S%z"),
"project_id": project_id,
"fuel_type": fuel_type,
"value": value if pd.notnull(value) else None,
"estimated": bool(estimated)
}
consumption_records_data.append(record)
return consumption_records_data
def test_consumption_data_interval_start_daily_missing_start_key_freq_D(
records_interval_start_daily_missing_start_key, fuel_type, unit_name):
with pytest.raises(ValueError):
cd = ConsumptionData(records_interval_start_daily_missing_start_key,
fuel_type,
unit_name,
freq="D")
def test_consumption_data_interval_end_daily_all_freq_2D(
records_interval_end_daily_all, fuel_type, unit_name):
cd = ConsumptionData(records_interval_end_daily_all,
fuel_type, unit_name, freq="2D")
assert cd.freq_timedelta == timedelta(days=2)
assert_allclose(cd.data.values,[1,3,5], rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2014,12,30)
def test_consumption_data_interval_start_daily_missing_date_freq_D(
records_interval_start_daily_missing_date, fuel_type, unit_name):
cd = ConsumptionData(records_interval_start_daily_missing_date,
fuel_type, unit_name, freq="D")
assert cd.freq_timedelta == timedelta(days=1)
assert_allclose(cd.data.values,[1,2,np.nan,4,5], rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
def get_consumption_data_objects(self, fuel_type_default="electricity"):
''' Retrieve all consumption records stored as IntervalReading elements
in the given ESPI Energy Usage XML.
Consumption records are grouped by fuel type and returned in
ConsumptionData objects.
Parameters
----------
fuel_type_default : str
Default fuel type to use in parser if ReadingType/commodity field
is missing.
Yields
------
ConsumptionData : eemeter.consumption.ConsumptionData
Consumption data grouped by fuel type.
'''
# Get all consumption records, group by fuel type.
fuel_type_records = defaultdict(list)
for record in self.get_consumption_records():
fuel_type_records[record["fuel_type"]].append(record)
# Wrap records in ConsumptionData objects.
for fuel_type, records in fuel_type_records.items():
if fuel_type is None:
fuel_type = fuel_type_default
yield ConsumptionData(records,
fuel_type,
records[0]["unit_name"],
record_type='arbitrary')
def test_consumption_data_interval_start_daily_all_invalid_unit_name(
records_interval_end_daily_all, fuel_type):
with pytest.raises(ValueError):
cd = ConsumptionData(records_interval_end_daily_all,
fuel_type,
"invalid",
freq="D")
def test_consumption_data_arbitrary_end(records_arbitrary_end,
fuel_type, unit_name, record_type_arbitrary_end):
cd = ConsumptionData(records_arbitrary_end,
fuel_type, unit_name, record_type=record_type_arbitrary_end)
assert_allclose(cd.data.values,[0,0,0,1,0,np.nan],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2014,2,2)
assert cd.data.index[5] == datetime(2015,2,1)
assert cd.freq is None
assert cd.freq_timedelta is None
assert cd.pulse_value is None
generated_records = cd.records(record_type=record_type_arbitrary_end)
assert len(generated_records) == 6
assert generated_records[0] == {"end": datetime(2014,2,2),"value": np.nan, "estimated": False}
assert generated_records[5] == {"end": datetime(2015,2,1),"value":0, "estimated": False}
def test_downsample_single_record():
records = [{
"start": datetime(2015, 1, 1, tzinfo=pytz.UTC),
"value": 0,
"estimated": False
}]
cd = ConsumptionData(records,
"electricity",
"kWh",
record_type="arbitrary_start")
cd_down = cd.downsample('D')
assert_allclose(cd.data, cd_down.data)
assert_allclose(cd.estimated, cd_down.estimated)
def test_consumption_data_interval_start_daily_missing_value_freq_D(
records_interval_start_daily_missing_value):
cd = ConsumptionData(records_interval_start_daily_missing_value,
"electricity", "kWh", freq="D")
assert cd.freq_timedelta == timedelta(days=1)
assert_allclose(cd.data.values,[1,2,np.nan,4,5], rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
def consumption_data_1():
records = [
{"start": datetime(2012,9,26), "value": 191},
{"start": datetime(2012,10,24), "value": 243},
{"start": datetime(2012,11,21), "value": 370},
{"start": datetime(2012,12,27), "value": 404},
{"start": datetime(2013,1,29), "value": 321},
{"start": datetime(2013,2,26), "value": 332},
{"start": datetime(2013,3,27), "value": 287},
{"start": datetime(2013,4,25), "value": 209},
{"start": datetime(2013,5,23), "value": 247},
{"start": datetime(2013,6,22), "value": 954},
{"start": datetime(2013,7,26), "value": 230},
{"start": datetime(2013,8,22), "value": 616},
{"start": datetime(2013,9,25), "value": 189},
{"start": datetime(2013,10,23), "value": 295},
{"start": datetime(2013,11,22), "value": 478},
{"start": datetime(2013,12,27), "value": 532},
{"start": datetime(2014,1,30), "value": 405},
{"start": datetime(2014,2,27), "value": 370},
{"start": datetime(2014,3,29), "value": 265},
{"start": datetime(2014,4,26), "value": 234},
{"start": datetime(2014,5,28), "value": 339},
{"start": datetime(2014,6,25), "value": 473},
{"start": datetime(2014,7,25), "value": 382},
{"start": datetime(2014,8,23), "end": datetime(2014,9,25),
"value": 451}]
return ConsumptionData(records, "electricity", "kWh",
record_type="arbitrary_start")
def test_consumption_data_interval_end_daily_all_freq_12H(
records_interval_end_daily_all, fuel_type, unit_name):
cd = ConsumptionData(records_interval_end_daily_all,
fuel_type, unit_name, freq="12H")
assert cd.freq_timedelta == timedelta(seconds=60*60*12)
assert_allclose(cd.data.values,[1,np.nan,2,np.nan,3,np.nan,4,np.nan,5],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2014,12,31,12)
def consumption_data_15min():
records = [{
"start": datetime(2015, 1, 1, tzinfo=pytz.UTC) + timedelta(seconds=i*900),
"value": np.nan if i % 30 == 0 or 1000 < i < 2000 else 0.1,
"estimated": i % 3 == 0 or 2000 < i < 3000,
} for i in range(10000)]
return ConsumptionData(records, "electricity", "kWh", record_type="arbitrary_start")
def test_consumption_data_interval_start_15min(
records_interval_start_15min, fuel_type, unit_name):
cd = ConsumptionData(records_interval_start_15min,
fuel_type, unit_name, freq="15T")
assert cd.freq_timedelta == timedelta(seconds=60*15)
assert_allclose(cd.data.values,[1,2,3,4,5,6], rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
assert cd.pulse_value is None
def test_consumption_data_arbitrary_start(records_arbitrary_start,
fuel_type, unit_name, record_type_arbitrary_start):
cd = ConsumptionData(records_arbitrary_start,
fuel_type, unit_name, record_type=record_type_arbitrary_start)
assert_allclose(cd.data.values,[0,0,0,1,np.nan],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
assert cd.data.index[4] == datetime(2015,2,1)
assert cd.freq is None
assert cd.freq_timedelta is None
assert cd.pulse_value is None
generated_records = cd.records(record_type=record_type_arbitrary_start)
assert len(generated_records) == 5
assert generated_records[0] == {"start": datetime(2015,1,1), "value": 0, "estimated": False}
assert generated_records[4]["start"] == datetime(2015,2,1)
assert pd.isnull(generated_records[4]["value"])
assert len(generated_records[4].keys()) == 3
def test_consumption_data_arbitrary_start(records_arbitrary_start,
fuel_type, unit_name, record_type_arbitrary_start):
cd = ConsumptionData(records_arbitrary_start,
fuel_type, unit_name, record_type=record_type_arbitrary_start)
assert_allclose(cd.data.values,[0,0,0,1,np.nan],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
assert cd.data.index[4] == datetime(2015,2,1)
assert cd.freq is None
assert cd.freq_timedelta is None
assert cd.pulse_value is None
generated_records = cd.records(record_type=record_type_arbitrary_start)
assert len(generated_records) == 5
assert generated_records[0] == {"start": datetime(2015,1,1), "value": 0, "estimated": False}
assert generated_records[4]["start"] == datetime(2015,2,1)
assert pd.isnull(generated_records[4]["value"])
assert len(generated_records[4].keys()) == 3
def test_consumtion_data_arbitrary_overlap(records_arbitrary_overlap, recwarn):
cd = ConsumptionData(records_arbitrary_overlap,
"electricity", "kWh", record_type="arbitrary")
assert_allclose(cd.data.values,[np.nan,np.nan,1,np.nan,0,np.nan],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
assert cd.data.index[5] == datetime(2015,2,1)
w = recwarn.pop(UserWarning)
assert issubclass(w.category, UserWarning)
def test_consumption_data_interval_start_daily_overlapping_date_freq_D(
records_interval_start_daily_overlapping_date, recwarn):
cd = ConsumptionData(records_interval_start_daily_overlapping_date,
"electricity", "kWh", freq="D")
assert cd.freq_timedelta == timedelta(days=1)
assert_allclose(cd.data.values,[1,2,3,4,5], rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
w = recwarn.pop(UserWarning)
assert issubclass(w.category, UserWarning)
def consumption_data_kWh_arbitrary():
records = [{
"start": datetime(2015, 1, i + 1),
"end": datetime(2015, 1, i + 2),
"value": 1
} for i in range(10)]
return ConsumptionData(records,
"electricity",
"kWh",
record_type="arbitrary")
def test_consumption_data_arbitrary_basic(records_arbitrary_basic,
fuel_type, unit_name, record_type_arbitrary):
cd = ConsumptionData(records_arbitrary_basic,
fuel_type, unit_name, record_type=record_type_arbitrary)
assert cd.freq is None
assert cd.freq_timedelta is None
assert cd.pulse_value is None
assert_allclose(cd.data.values,[np.nan,np.nan,1,np.nan,0,0,np.nan],
rtol=RTOL, atol=ATOL)
assert cd.data.index[0] == datetime(2015,1,1)
def test_downsample_two_day():
records = [{
"start":
datetime(2015, 1, 1, tzinfo=pytz.UTC) + timedelta(days=2 * i),
"value":
1.0,
"estimated":
False,
} for i in range(100)]
cd = ConsumptionData(records,
"electricity",
"kWh",
record_type="arbitrary_start")
cd_down = cd.downsample('D')
assert_allclose(cd.data, cd_down.data)
assert_allclose(cd.estimated, cd_down.estimated)
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 test_consumption_data_init_from_arbitrary_data(
consumption_data_kWh_arbitrary):
cd = ConsumptionData(records=None,
fuel_type=consumption_data_kWh_arbitrary.fuel_type,
unit_name=consumption_data_kWh_arbitrary.unit_name,
data=consumption_data_kWh_arbitrary.data,
estimated=consumption_data_kWh_arbitrary.estimated)
cd.freq_timedelta is None
with pytest.raises(ValueError):
cd = ConsumptionData(records=None,
fuel_type=consumption_data_kWh_arbitrary.fuel_type,
unit_name=consumption_data_kWh_arbitrary.unit_name,
data=consumption_data_kWh_arbitrary.data)
with pytest.raises(ValueError):
cd = ConsumptionData(records=[],
fuel_type=consumption_data_kWh_arbitrary.fuel_type,
unit_name=consumption_data_kWh_arbitrary.unit_name,
data=consumption_data_kWh_arbitrary.data,
estimated=consumption_data_kWh_arbitrary.estimated)
def test_total_days_blank_consumption(consumption_data_blank):
consumption_data_blank = ConsumptionData([], "electricity", "kWh", "arbitrary_start")
assert consumption_data_blank.total_days() == 0
