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