def test_for_each_fuel_type(): meter_yaml = """ !obj:eemeter.meter.ForEachFuelType { fuel_types: [electricity,natural_gas], fuel_unit_strs: [kWh,therms], meter: !obj:eemeter.meter.Sequence { sequence: [ !obj:eemeter.meter.DummyMeter { input_mapping: { fuel_type: value, } }, !obj:eemeter.meter.DummyMeter { input_mapping: { value_one: value, }, output_mapping: { result: result_one } } ] } } """ meter = load(meter_yaml) result = meter.evaluate(value_one=1) assert result["result_electricity"] == "electricity" assert result["result_natural_gas"] == "natural_gas" assert result["result_one_electricity"] == 1 assert result["result_one_natural_gas"] == 1 with pytest.raises(ValueError): meter = load("!obj:eemeter.meter.ForEachFuelType { fuel_types:[electricity],fuel_unit_strs:[], meter: null }")
def test_setting(): settings = {"heating_config": 10} loaded = load("a: !setting heating_config", settings=settings) assert loaded['a'] == 10 # no settings provided with pytest.raises(KeyError): loaded = load("a: !setting heating_config")
def test_gross_savings_metric(generated_consumption_history_pre_post_with_gross_savings_1, gsod_722880_2012_2014_weather_source): meter_yaml = """ !obj:eemeter.meter.Sequence { extras: { fuel_unit_str: "kWh", fuel_type: "electricity", }, sequence: [ !obj:eemeter.meter.PrePost { splittable_args: ["consumption_history"], pre_meter: !obj:eemeter.meter.TemperatureSensitivityParameterOptimizationMeter &meter { temperature_unit_str: "degF", model: !obj:eemeter.models.TemperatureSensitivityModel &model { cooling: True, heating: True, initial_params: { base_consumption: 0, heating_slope: 0, cooling_slope: 0, heating_reference_temperature: 60, cooling_reference_temperature: 70, }, param_bounds: { base_consumption: [0,2000], heating_slope: [0,200], cooling_slope: [0,200], heating_reference_temperature: [55,65], cooling_reference_temperature: [65,75], }, }, }, post_meter: *meter, }, !obj:eemeter.meter.GrossSavingsMeter { fuel_unit_str: "kWh", fuel_type: "electricity", temperature_unit_str: "degF", model: *model, } ] } """ meter = load(meter_yaml) ch, pre_params, post_params, retrofit, savings = generated_consumption_history_pre_post_with_gross_savings_1 result = meter.evaluate(consumption_history=ch, weather_source=gsod_722880_2012_2014_weather_source, retrofit_start_date=retrofit, retrofit_completion_date=retrofit) assert_allclose(result['temp_sensitivity_params_pre'], pre_params, rtol=RTOL, atol=ATOL) assert_allclose(result['temp_sensitivity_params_post'], post_params, rtol=RTOL, atol=ATOL) assert isinstance(result["consumption_history_pre"],ConsumptionHistory) assert isinstance(result["consumption_history_post"],ConsumptionHistory) assert_allclose(result["gross_savings"],savings, rtol=RTOL, atol=ATOL)
def test_meets_thresholds(): meter_yaml = """ !obj:eemeter.meter.MeetsThresholds { input_mapping: { "one": {}, "two": {}, "three": {}, "four": {}, }, equations: [ ["one", "<", 1, 0, 0, "one_lt_zero"], ["two", "<=", 1, "two", 0, "two_lte_two"], ["three", ">", .5, "four", 0, "three_gt_half_four"], ["four", ">=", "two", 3, 0, "four_gte_twice_three"], ["four", ">=", 2, 1, "two", "four_gte_four"], ], output_mapping: { "one_lt_zero": {}, "two_lte_two": {}, "three_gt_half_four": {}, "four_gte_twice_three": {}, "four_gte_four": {}, }, } """ meter = load(meter_yaml) data_collection = DataCollection(one=1, two=2, three=3.0, four=4) result = meter.evaluate(data_collection) assert not result.get_data("one_lt_zero").value assert result.get_data("two_lte_two").value assert result.get_data("three_gt_half_four").value assert not result.get_data("four_gte_twice_three").value assert result.get_data("four_gte_four").value
def test_sequential_meter(): meter_yaml = """ !obj:eemeter.meter.Sequence { sequence: [ !obj:eemeter.meter.DummyMeter { input_mapping: { "value": {}, }, output_mapping: { "result": {"name":"value1"}, }, }, !obj:eemeter.meter.DummyMeter { input_mapping: { "value": { "name": "value1"}, }, output_mapping: { "result": {}, }, }, !obj:eemeter.meter.DummyMeter { input_mapping: { "value": {}, }, output_mapping: { "result": {"name": "result1"}, }, }, ] } """ meter = load(meter_yaml) data_collection = DataCollection(value=10) result = meter.evaluate(data_collection) assert result.get_data("value") is None assert result.get_data("value1").value == 10 assert result.get_data("result").value == 10 assert result.get_data("result1").value == 10
def test_debug_meter(): meter_yaml=""" !obj:eemeter.meter.Debug { } """ meter = load(meter_yaml)
def test_weather_normalization(consumption_history_1, gsod_722880_2012_2014_weather_source, tmy3_722880_weather_source): meter_yaml = """ !obj:eemeter.meter.SequentialMeter { sequence: [ !obj:eemeter.meter.TemperatureSensitivityParameterOptimizationMeter { fuel_unit_str: "kWh", fuel_type: "electricity", temperature_unit_str: "degF", model: !obj:eemeter.models.DoubleBalancePointModel &model { x0: [1.,1.,1.,60.,7.], bounds: [[0,200],[0,200],[0,2000],[55,65],[2,12]], } }, !obj:eemeter.meter.AnnualizedUsageMeter { temperature_unit_str: "degF", model: *model } ] } """ meter = load(meter_yaml) result = meter.evaluate(consumption_history=consumption_history_1, weather_source=gsod_722880_2012_2014_weather_source, weather_normal_source=tmy3_722880_weather_source) assert arrays_similar(result['temp_sensitivity_params'], [0.013456,0.029507,8.341199,65,3.8]) assert abs(result['annualized_usage'] - 3087.8412641) < EPSILON
def __init__(self,temperature_unit_str="degC", heating_ref_temp_low=None, heating_ref_temp_x0=None, heating_ref_temp_high=None, cooling_ref_temp_low=None, cooling_ref_temp_x0=None, cooling_ref_temp_high=None, electricity_heating_slope_high=None, natural_gas_heating_slope_high=None, electricity_cooling_slope_high=None, **kwargs): super(PRISMMeter, self).__init__(**kwargs) if temperature_unit_str not in ["degF","degC"]: raise ValueError("Invalid temperature_unit_str: should be one of 'degF' or 'degC'.") self.temperature_unit_str = temperature_unit_str self.heating_ref_temp_low=heating_ref_temp_low self.heating_ref_temp_x0=heating_ref_temp_x0 self.heating_ref_temp_high=heating_ref_temp_high self.electricity_heating_slope_high=electricity_heating_slope_high self.natural_gas_heating_slope_high=natural_gas_heating_slope_high self.cooling_ref_temp_low=cooling_ref_temp_low self.cooling_ref_temp_x0=cooling_ref_temp_x0 self.cooling_ref_temp_high=cooling_ref_temp_high self.electricity_cooling_slope_high=electricity_cooling_slope_high self.meter = load(self._meter_yaml())
def test_pre_post_parameters(consumption_history_1, gsod_722880_2012_2014_weather_source): meter_yaml = """ !obj:eemeter.meter.PrePostMeter { splittable_args: ["consumption_history"], meter: !obj:eemeter.meter.TemperatureSensitivityParameterOptimizationMeter { fuel_unit_str: "kWh", fuel_type: "electricity", temperature_unit_str: "degF", model: !obj:eemeter.models.DoubleBalancePointModel { x0: [1.,1.,1.,60.,7.], bounds: [[0,200],[0,200],[0,2000],[55,65],[2,12]], } }, } """ meter = load(meter_yaml) result = meter.evaluate(consumption_history=consumption_history_1, weather_source=gsod_722880_2012_2014_weather_source, retrofit_start_date=datetime(2013,9,25), retrofit_end_date=datetime(2013,9,25)) assert arrays_similar(result["temp_sensitivity_params_pre"], [0.016883,0.042749,6.013131,65,3.3]) assert arrays_similar(result["temp_sensitivity_params_post"], [0.059923,0.001983,11.129708,55,2]) assert isinstance(result["consumption_history_pre"],ConsumptionHistory) assert isinstance(result["consumption_history_post"],ConsumptionHistory)
def test_for(): meter_yaml = """ !obj:eemeter.meter.For { variable: { name: value, }, iterable: { name: iterable, }, meter: !obj:eemeter.meter.DummyMeter { input_mapping: { value: {} }, output_mapping: { result: {} }, } } """ meter = load(meter_yaml) iterable = [ { "value": 1, "tags": ["one"] }, { "value": 2, "tags": ["two"] }] data_collection = DataCollection(iterable=iterable) result = meter.evaluate(data_collection) assert 1 == result.get_data("result", tags=["one"]).value assert 2 == result.get_data("result", tags=["two"]).value
def test_dummy_meter(): meter_yaml=""" !obj:eemeter.meter.DummyMeter { } """ meter = load(meter_yaml)
def test_dummy_meter_tags(data_collection): meter_yaml = """ !obj:eemeter.meter.DummyMeter { input_mapping: { "value": { "name":"name", "tags": ["tag"], }, }, output_mapping: { "result": { "name":"result_1", "tags": ["tag_1"], }, }, } """ meter = load(meter_yaml) result = meter.evaluate(data_collection) assert result.get_data("result_1").value == "value" assert result.get_data("result_1",tags=["tag_1"]).value == "value" assert result.get_data("result_1",tags=["tag"]) == None assert result.get_data("result") == None assert result.get_data(name="name") == None
def test_conditional_meter_without_params(): meter_yaml=""" !obj:eemeter.meter.Condition { condition_parameter: "electricity_present", } """ meter = load(meter_yaml) assert isinstance(meter.evaluate(electricity_present=True),dict) assert isinstance(meter.evaluate(electricity_present=False),dict)
def __init__(self, temperature_unit_str="degC", settings={}, **kwargs): super(DefaultResidentialMeter, self).__init__(**kwargs) if temperature_unit_str not in ["degF","degC"]: raise ValueError("Invalid temperature_unit_str: should be one of 'degF' or 'degC'.") self.temperature_unit_str = temperature_unit_str self.settings = self.process_settings(settings) self.meter = load(self.yaml, self.settings)
def __init__(self, temperature_unit_str, settings={}, **kwargs): super(BPI_2400_S_2012_ModelCalibrationUtilityBillCriteria, self).__init__(**kwargs) if temperature_unit_str not in ["degF","degC"]: raise ValueError("Invalid temperature_unit_str: should be one of 'degF' or 'degC'.") self.temperature_unit_str = temperature_unit_str self.settings = self.process_settings(settings) self.meter = load(self.yaml, self.settings)
def test_princeton_scorekeeping_method(consumption_history_1, gsod_722880_2012_2014_weather_source, tmy3_722880_weather_source): meter = load("!obj:eemeter.meter.PRISMMeter {}") result = meter.evaluate(consumption_history=consumption_history_1, weather_source=gsod_722880_2012_2014_weather_source, weather_normal_source=tmy3_722880_weather_source) assert result["electricity_presence"] assert not result["natural_gas_presence"]
def test_temperature_sensitivity_parameter_optimization( generated_consumption_data_1, gsod_722880_2012_2014_weather_source): meter_yaml = """ !obj:eemeter.meter.TemperatureSensitivityParameterOptimizationMeter { temperature_unit_str: "degF", model: !obj:eemeter.models.AverageDailyTemperatureSensitivityModel { cooling: True, heating: True, initial_params: { base_daily_consumption: 0, heating_slope: 0, cooling_slope: 0, heating_balance_temperature: 60, cooling_balance_temperature: 70, }, param_bounds: { base_daily_consumption: [0,2000], heating_slope: [0,200], cooling_slope: [0,200], heating_balance_temperature: [55,65], cooling_balance_temperature: [65,75], }, }, input_mapping: { "consumption_data": {}, "weather_source": {}, "energy_unit_str": {}, }, output_mapping: { "temp_sensitivity_params": {}, "n_days": {}, "average_daily_usages": {}, "estimated_average_daily_usages": {}, }, } """ meter = load(meter_yaml) cd, params = generated_consumption_data_1 data_collection = DataCollection( consumption_data=cd, weather_source=gsod_722880_2012_2014_weather_source, energy_unit_str="kWh") result = meter.evaluate(data_collection) assert_allclose(result.get_data('temp_sensitivity_params').value.to_list(), params.to_list(), rtol=RTOL, atol=ATOL) assert result.get_data('n_days') is not None assert result.get_data('average_daily_usages') is not None assert result.get_data('estimated_average_daily_usages') is not None
def test_fuel_type_presence_meter(consumption_history_1): meter_yaml = """ !obj:eemeter.meter.FuelTypePresenceMeter { fuel_types: [electricity,natural_gas] } """ meter = load(meter_yaml) result = meter.evaluate(consumption_history=consumption_history_1) assert result["electricity_presence"] assert not result["natural_gas_presence"]
def test_conditional_meter_without_params(): meter_yaml=""" !obj:eemeter.meter.Condition { condition: { "name": "electricity_present", } } """ meter = load(meter_yaml) data_collection = DataCollection(electricity_present=True) assert meter.evaluate(data_collection).count() == 0 data_collection = DataCollection(electricity_present=False) assert meter.evaluate(data_collection).count() == 0
def test_dummy_meter_auxiliary_inputs(): meter_yaml = """ !obj:eemeter.meter.DummyMeter { auxiliary_inputs: { "value": "aux" }, output_mapping: { "result": {}, }, } """ meter = load(meter_yaml) data_collection = DataCollection() result = meter.evaluate(data_collection) assert result.get_data(name="result").value == "aux"
def test_sequential_meter(): meter_yaml = """ !obj:eemeter.meter.Sequence { sequence: [ !obj:eemeter.meter.DummyMeter {}, ] }""" meter = load(meter_yaml) result = meter.evaluate(value=10) assert result["result"] == 10
def test_estimated_reading_consolidation_meter_single_fuel_type(consumption_data): meter_yaml = """ !obj:eemeter.meter.EstimatedReadingConsolidationMeter { input_mapping: {"consumption_data": {}}, output_mapping: {"consumption_data_no_estimated": {}}, } """ meter = load(meter_yaml) data_collection = DataCollection(consumption_data=consumption_data) result = meter.evaluate(data_collection) values = result.get_data("consumption_data_no_estimated").value.data.values assert_allclose(values, np.array([0, 0, 0, np.nan]), rtol=RTOL, atol=ATOL)
def test_annualized_usage_meter( generated_consumption_history_with_annualized_usage_1, gsod_722880_2012_2014_weather_source, tmy3_722880_weather_source, ): meter_yaml = """ !obj:eemeter.meter.Sequence { sequence: [ !obj:eemeter.meter.TemperatureSensitivityParameterOptimizationMeter { temperature_unit_str: "degF", model: !obj:eemeter.models.TemperatureSensitivityModel &model { cooling: True, heating: True, initial_params: { base_consumption: 0, heating_slope: 0, cooling_slope: 0, heating_reference_temperature: 60, cooling_reference_temperature: 70, }, param_bounds: { base_consumption: [0,2000], heating_slope: [0,200], cooling_slope: [0,200], heating_reference_temperature: [55,65], cooling_reference_temperature: [65,75], }, }, }, !obj:eemeter.meter.AnnualizedUsageMeter { temperature_unit_str: "degF", model: *model } ] } """ meter = load(meter_yaml) ch, params, annualized_usage = generated_consumption_history_with_annualized_usage_1 result = meter.evaluate( consumption_history=ch, weather_source=gsod_722880_2012_2014_weather_source, weather_normal_source=tmy3_722880_weather_source, fuel_unit_str="kWh", fuel_type="electricity", ) assert_allclose(result["temp_sensitivity_params"], params, rtol=RTOL, atol=ATOL) assert_allclose(result["annualized_usage"], annualized_usage, rtol=RTOL, atol=ATOL)
def test_conditional_meter(): meter_yaml=""" !obj:eemeter.meter.Condition { condition_parameter: "electricity_present", success: !obj:eemeter.meter.DummyMeter { input_mapping: {"success":"value"}, }, failure: !obj:eemeter.meter.DummyMeter { input_mapping: {"failure":"value"}, }, } """ meter = load(meter_yaml) assert meter.evaluate(electricity_present=True,success="success",failure="failure")["result"] == "success" assert meter.evaluate(electricity_present=False,success="success",failure="failure")["result"] == "failure"
def test_tag_filter(): meter_yaml = """ !obj:eemeter.meter.TagFilter { meter: !obj:eemeter.meter.DummyMeter { input_mapping: { value: {} }, output_mapping: { result: {} }, } } """ meter = load(meter_yaml) data_collection = DataCollection() with pytest.raises(NotImplementedError): meter.evaluate(data_collection)
def test_switch(): meter_yaml = """ !obj:eemeter.meter.Switch { target: {name: target}, cases: { 1: !obj:eemeter.meter.DummyMeter { input_mapping: { value: {name: value_one} }, output_mapping: { result: {} }, }, 2: !obj:eemeter.meter.DummyMeter { input_mapping: { value: {name: value_two} }, output_mapping: { result: {} }, }, 3: !obj:eemeter.meter.DummyMeter { input_mapping: { value: {name: value_three} }, output_mapping: { result: {} }, }, }, default: !obj:eemeter.meter.DummyMeter { input_mapping: { value: {name: value_default} }, output_mapping: { result: {} }, } } """ meter = load(meter_yaml) data_collection = DataCollection(target=1, value_one=1, value_two=2, value_three=3, value_default=4) result1 = meter.evaluate(data_collection) data_collection = DataCollection(target=2, value_one=1, value_two=2, value_three=3, value_default=4) result2 = meter.evaluate(data_collection) data_collection = DataCollection(target=3, value_one=1, value_two=2, value_three=3, value_default=4) result3 = meter.evaluate(data_collection) data_collection = DataCollection(target=4, value_one=1, value_two=2, value_three=3, value_default=4) result4 = meter.evaluate(data_collection) data_collection = DataCollection(value_one=1, value_two=2, value_three=3, value_default=4) result5 = meter.evaluate(data_collection) assert 1 == result1.get_data("result").value assert 2 == result2.get_data("result").value assert 3 == result3.get_data("result").value assert 4 == result4.get_data("result").value assert None == result5.get_data("result")
def test_r_squared(): meter_yaml = """ !obj:eemeter.meter.RSquared { input_mapping: { "y": {}, "y_hat": {}}, output_mapping: { "r_squared": {}} } """ meter = load(meter_yaml) data_collection = DataCollection( y=np.array([12,13,414,12,23,12,32,np.nan]), y_hat=np.array([32,12,322,21,22,41,32,np.nan])) result = meter.evaluate(data_collection) assert_allclose(result.get_data("r_squared").value, 0.9276, rtol=RTOL, atol=ATOL)
def test_meter_base(): meter_yaml = """ !obj:eemeter.meter.DummyMeter { extras: { has_extra: true, }, output_mapping: { has_extra: has_extra, }, } """ meter = load(meter_yaml) result = meter.evaluate(value="dummy") assert result["result"] == "dummy" assert result["has_extra"]
def test_dummy_meter_auxiliary_outputs(data_collection): meter_yaml = """ !obj:eemeter.meter.DummyMeter { input_mapping: { "value": { "name":"name", }, }, output_mapping: { "result": { "name":"result", }, "aux_result": { "name":"aux_result", }, }, auxiliary_outputs: { "aux_result": "aux" }, } """ meter = load(meter_yaml) result = meter.evaluate(data_collection) assert result.get_data(name="result").value == "value" assert result.get_data(name="aux_result").value == "aux"
def test_cvrmse(): meter_yaml = """ !obj:eemeter.meter.CVRMSE { input_mapping: { "y": {}, "y_hat": {}, "params": {}}, output_mapping: { "cvrmse": {}} } """ meter = load(meter_yaml) data_collection = DataCollection( y=np.array([12,13,414,12,23,12,32,np.nan]), y_hat=np.array([32,12,322,21,22,41,32,np.nan]), params=BaseloadHeatingModelParameterType([1,3,4])) result = meter.evaluate(data_collection) assert_allclose(result.get_data("cvrmse").value, 59.79, rtol=RTOL, atol=ATOL)
def test_dummy_meter_output_duplication_list(data_collection): meter_yaml = """ !obj:eemeter.meter.DummyMeter { input_mapping: { "value": { "name":"name", }, }, output_mapping: { "result": [ { "name":"result1", }, { "name":"result2", }, ] }, } """ meter = load(meter_yaml) result = meter.evaluate(data_collection) assert result.get_data(name="result1").value == "value" assert result.get_data(name="result2").value == "value" assert result.get_data(name="name") == None
def test_estimated_average_daily_usage(generated_consumption_data_1,gsod_722880_2012_2014_weather_source): meter_yaml = """ !obj:eemeter.meter.EstimatedAverageDailyUsage { temperature_unit_str: "degF", model: !obj:eemeter.models.AverageDailyTemperatureSensitivityModel { cooling: True, heating: True, }, } """ meter = load(meter_yaml) cd,params = generated_consumption_data_1 result = meter.evaluate_raw( consumption_data=cd, weather_source=gsod_722880_2012_2014_weather_source, temp_sensitivity_params=params, energy_unit_str="kWh") assert result["estimated_average_daily_usages"] is not None assert result["n_days"] is not None
def test_conditional_meter(): meter_yaml=""" !obj:eemeter.meter.Condition { condition: { "name": "electricity_present" }, success: !obj:eemeter.meter.DummyMeter { input_mapping: {"value": {"name": "success"}}, output_mapping: {"result": {}}, }, failure: !obj:eemeter.meter.DummyMeter { input_mapping: {"value": {"name": "failure"}}, output_mapping: {"result": {}}, }, } """ meter = load(meter_yaml) data_collection = DataCollection(electricity_present=True, success="success", failure="failure") assert meter.evaluate(data_collection).get_data("result").value == "success" data_collection = DataCollection(electricity_present=False, success="success", failure="failure") assert meter.evaluate(data_collection).get_data("result").value == "failure"
def test_fuel_type_tag_filter(): meter_yaml = """ !obj:eemeter.meter.FuelTypeTagFilter { fuel_type_search_name: active_fuel_type, input_mapping: { active_fuel_type: {}, }, meter: !obj:eemeter.meter.Sequence { sequence: [ !obj:eemeter.meter.DummyMeter { input_mapping: { value: { name: active_fuel_type } }, output_mapping: { result: { name: result1 } }, }, !obj:eemeter.meter.DummyMeter { input_mapping: { value: {} }, output_mapping: { result: { name: result2 } }, } ] } } """ meter = load(meter_yaml) data_collection = DataCollection(active_fuel_type="electricity") data_collection_include = DataCollection(value="value_include") data_collection_exclude = DataCollection(value="value_exclude") data_collection.add_data_collection(data_collection_include, tagspace=["electricity"]) data_collection.add_data_collection(data_collection_exclude, tagspace=["natural_gas"]) output_data_collection = meter.evaluate(data_collection) assert output_data_collection.get_data("result1").value == "electricity" assert output_data_collection.get_data("result2").value == "value_include"
def test_obj_formats(simple_yaml): loaded = load(simple_yaml) assert isinstance(loaded, Decimal)
def test_obj(): loaded1 = load("a: !obj:decimal.Decimal { value : '1.23' }") assert isinstance(loaded1['a'], Decimal)
def __init__(self, settings={}, **kwargs): super(YamlDefinedMeter, self).__init__(**kwargs) self.settings = self.process_settings(settings) self.meter = load(self.yaml, self.settings)
def test_annualized_usage_meter( generated_consumption_data_with_annualized_usage_1, gsod_722880_2012_2014_weather_source, tmy3_722880_weather_source): meter_yaml = """ !obj:eemeter.meter.Sequence { sequence: [ !obj:eemeter.meter.TemperatureSensitivityParameterOptimizationMeter { temperature_unit_str: "degF", model: !obj:eemeter.models.AverageDailyTemperatureSensitivityModel &model { cooling: True, heating: True, initial_params: { base_daily_consumption: 0, heating_slope: 0, cooling_slope: 0, heating_balance_temperature: 60, cooling_balance_temperature: 70, }, param_bounds: { base_daily_consumption: [0,2000], heating_slope: [0,200], cooling_slope: [0,200], heating_balance_temperature: [55,65], cooling_balance_temperature: [65,75], }, }, input_mapping: { consumption_data: {}, weather_source: {}, energy_unit_str: {}, }, output_mapping: { temp_sensitivity_params: {name: model_params}, }, }, !obj:eemeter.meter.AnnualizedUsageMeter { temperature_unit_str: "degF", model: *model, input_mapping: { model_params: {}, weather_normal_source: {}, }, output_mapping: { annualized_usage: {}, }, } ] } """ meter = load(meter_yaml) cd, params, annualized_usage = \ generated_consumption_data_with_annualized_usage_1 data_collection = DataCollection( consumption_data=cd, weather_source=gsod_722880_2012_2014_weather_source, weather_normal_source=tmy3_722880_weather_source, energy_unit_str="kWh") result = meter.evaluate(data_collection) assert_allclose(result.get_data('model_params').value.to_list(), params.to_list(), rtol=RTOL, atol=ATOL) assert_allclose(result.get_data('annualized_usage').value, annualized_usage, rtol=RTOL, atol=ATOL)