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_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_debug_meter():
meter_yaml="""
!obj:eemeter.meter.Debug {
}
"""
meter = load(meter_yaml)
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_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)
