def test_demand_is_scaled(base_grid, raw_demand):
base_demand = raw_demand[base_grid.id2zone.keys()]
n_zone = param["n_zone_to_scale"]
ct = ChangeTable(base_grid)
ct.scale_demand(
zone_id={
z: f
for z, f in zip(
np.random.choice([i for i in base_grid.zone2id.values()],
size=n_zone,
replace=False),
2 * np.random.random(size=n_zone),
)
})
tg = TransformGrid(base_grid, ct.ct)
transformed_grid = tg.get_grid()
empty_scenario_info = {
} # scenario_info not needed since profile_input is mocked
tp = TransformProfile(empty_scenario_info, transformed_grid, ct.ct)
transformed_profile = tp.get_profile("demand")
assert not base_demand.equals(transformed_profile)
scaled_zone = list(ct.ct["demand"]["zone_id"].keys())
unscaled_zone = set(base_grid.id2zone.keys()) - set(scaled_zone)
factor = list(ct.ct["demand"]["zone_id"].values())
assert transformed_profile[scaled_zone].equals(
base_demand[scaled_zone].multiply(factor, axis=1))
if unscaled_zone:
assert transformed_profile[list(unscaled_zone)].equals(
base_demand[list(unscaled_zone)])
def test_add_electrification_by_zone():
obj = ChangeTable(Grid("Eastern"))
kind = "building"
info = {
"New York City": {
"res_cooking": {
"advanced_heat_pump_v2": 0.7
}
},
"Western North Carolina": {
"com_hot_water": {
"standard_heat_pump_v1": 0.5,
"advanced_heat_pump_v2": 0.5,
}
},
}
add_electrification(obj, kind, {"zone": info})
sf = {"standard_heat_pump_v1": 0.2, "advanced_heat_pump_v2": 0.8}
info = {"Maine": {"res_cooking": sf}}
add_electrification(obj, kind, {"zone": info})
result = obj.ct[kind]
assert "Maine" in result["zone"]
assert "New York City" in result["zone"]
def test_add_electrification():
obj = ChangeTable(Grid("Texas"))
kind = "building"
sf = {"standard_heat_pump_v1": 0.7, "advanced_heat_pump_v2": 0.3}
info = {"res_heating": sf}
add_electrification(obj, kind, {"grid": info})
with pytest.raises(ValueError):
add_electrification(obj, "foo", {"grid": info})
def __init__(self, ssh_client):
"""Constructor.
"""
self.interconnect = ['Western']
self.profile = CSV(self.interconnect, ssh_client)
self.change_table = ChangeTable(self.interconnect)
table = get_scenario_table(ssh_client)
self.existing = table[table.interconnect == self.name]
def __init__(self, grid_model, interconnect, table):
"""Constructor."""
mi = ModelImmutables(grid_model)
self.grid_model = mi.model
self.interconnect = mi.interconnect_to_name(interconnect)
self.base_grid = Grid(interconnect, source=grid_model)
self.change_table = ChangeTable(self.base_grid)
self.existing = table[table.interconnect == self.interconnect]
def test_add_electrification_combined():
obj = ChangeTable(Grid("Eastern"))
kind = "building"
sf = {"standard_heat_pump_v1": 0.2, "advanced_heat_pump_v2": 0.8}
zone = {"Maine": {"res_cooking": sf}}
grid = {"res_heating": sf}
info = {"grid": grid, "zone": zone}
add_electrification(obj, kind, info)
assert info == obj.ct[kind]
def get_change_table_for_new_plant_addition(base_grid, resource):
n_plant = param["n_plant_to_add"]
new_plant_bus_id = np.random.choice(base_grid.bus.index,
size=n_plant,
replace=False)
new_plant_pmax = 10 + 240 * np.random.random(size=n_plant)
new_plant = []
for b, p in zip(new_plant_bus_id, new_plant_pmax):
new_plant.append({"type": resource, "bus_id": b, "Pmax": p})
ct = ChangeTable(base_grid)
ct.add_plant(new_plant)
return ct.ct
def get_change_table_for_id_scaling(base_grid, resource):
n_plant = param["n_plant_to_scale"]
plants = get_plant_with_resource(base_grid, resource)
ct = ChangeTable(base_grid)
ct.scale_plant_capacity(
resource,
plant_id={
z: f
for z, f in zip(
np.random.choice(plants, size=n_plant, replace=False),
2 * np.random.random(size=n_plant),
)
},
)
return ct.ct
def get_change_table_for_zone_scaling(base_grid, resource):
n_zone = param["n_zone_to_scale"]
zones = get_zone_with_resource(base_grid, resource)
ct = ChangeTable(base_grid)
ct.scale_plant_capacity(
resource,
zone_name={
z: f
for z, f in zip(
np.random.choice(zones, size=n_zone, replace=False),
2 * np.random.random(size=n_zone),
)
},
)
return ct.ct
def test_flexible_demand_profiles_are_trimmed(base_grid,
raw_demand_flexibility_up,
raw_demand_flexibility_dn,
monkeypatch):
monkeypatch.setattr(Context, "get_data_access",
MockContext().get_data_access)
data_access = Context.get_data_access()
# Specify the fake demand flexibility profiles from MockInputData
zone_keys = [f"zone.{z}" for z in base_grid.id2zone.keys()]
base_demand_flexibility_up = raw_demand_flexibility_up[zone_keys]
base_demand_flexibility_dn = raw_demand_flexibility_dn[zone_keys]
# Create fake files in the expected directory path
exp_path = f"raw/{base_grid.grid_model}"
for csv_file in (
"demand_flexibility_up_Test.csv",
"demand_flexibility_dn_Test.csv",
):
with data_access.write(exp_path + "/" + csv_file) as f:
pd.DataFrame().to_csv(f)
# Specify the change table
ct = ChangeTable(base_grid)
ct.add_demand_flexibility({
"demand_flexibility_up": "Test",
"demand_flexibility_dn": "Test",
"demand_flexibility_duration": 6,
})
# Transform the grid object accordingly
tg = TransformGrid(base_grid, ct.ct)
transformed_grid = tg.get_grid()
# Test that the demand flexibility profiles are pruned
empty_scenario_info = {"grid_model": base_grid.grid_model}
tp = TransformProfile(empty_scenario_info, transformed_grid, ct.ct)
transformed_demand_flexibility_up = tp.get_profile("demand_flexibility_up")
transformed_demand_flexibility_dn = tp.get_profile("demand_flexibility_dn")
assert base_demand_flexibility_up.equals(transformed_demand_flexibility_up)
assert base_demand_flexibility_dn.equals(transformed_demand_flexibility_dn)
def test_aggregate_demand():
grid = Grid("Texas")
ct = ChangeTable(grid)
kind = "building"
zone_info = {"East": {"res_cooking": {"advanced_heat_pump_v2": 0.7}}}
grid_info = {"res_cooking": {"advanced_heat_pump_v2": 0.3}}
ct.add_electrification(kind, {"zone": zone_info, "grid": grid_info})
mock_input = MockProfileInput(grid)
demand = mock_input.get_data(None, "demand")
mock_input.get_profile = lambda *args: demand
td = TransformDemand(grid, ct, kind)
td._profile_data = mock_input
result = td.value()
pd.testing.assert_series_equal(0.7 * demand.loc[:, 308], result.loc[:,
308])
pd.testing.assert_frame_equal(0.3 * demand.loc[:, :307],
result.loc[:, :307])
def test_profile_mappings():
grid = Grid("Texas")
ct = ChangeTable(grid)
grid_info = {"res_heating": {"standard_heat_pump_v2": 0.3}}
zone_info = {
"East": {
"res_cooking": {
"advanced_heat_pump_v2": 0.7
}
},
"Coast": {
"com_hot_water": {
"standard_heat_pump_v1": 0.6,
"advanced_heat_pump_v2": 0.4,
}
},
"Far West": {
"res_cooking": {
"standard_heat_pump_v1": 0.2,
"advanced_heat_pump_v2": 0.3
}
},
}
kind = "building"
ct.add_electrification(kind, {"zone": zone_info, "grid": grid_info})
td = TransformDemand(grid, ct, kind)
actual = td.p2g
expected = {"res_heating_standard_heat_pump_v2.csv": 0.3}
assert expected == actual
actual = td.p2z
expected = {
"res_cooking_advanced_heat_pump_v2.csv": [(308, 0.7), (301, 0.3)],
"com_hot_water_standard_heat_pump_v1.csv": [(307, 0.6)],
"com_hot_water_advanced_heat_pump_v2.csv": [(307, 0.4)],
"res_cooking_standard_heat_pump_v1.csv": [(301, 0.2)],
}
assert expected == actual
def test_demand_is_scaled(base_grid):
input_data = InputData()
demand_info = {
"interconnect": "_".join(interconnect),
"grid_model": "usa_tamu",
"base_demand": param["demand"],
}
raw_demand = input_data.get_data(demand_info, "demand")
base_demand = raw_demand[base_grid.id2zone.keys()]
n_zone = param["n_zone_to_scale"]
ct = ChangeTable(base_grid)
ct.scale_demand(
zone_id={
z: f
for z, f in zip(
np.random.choice(
[i for i in base_grid.zone2id.values()], size=n_zone, replace=False
),
2 * np.random.random(size=n_zone),
)
}
)
tg = TransformGrid(base_grid, ct.ct)
transformed_grid = tg.get_grid()
tp = TransformProfile(demand_info, transformed_grid, ct.ct)
transformed_profile = tp.get_profile("demand")
assert not base_demand.equals(transformed_profile)
scaled_zone = list(ct.ct["demand"]["zone_id"].keys())
unscaled_zone = set(base_grid.id2zone.keys()) - set(scaled_zone)
factor = list(ct.ct["demand"]["zone_id"].values())
assert transformed_profile[scaled_zone].equals(
base_demand[scaled_zone].multiply(factor, axis=1)
)
if unscaled_zone:
assert transformed_profile[unscaled_zone].equals(base_demand[unscaled_zone])
def ct():
return ChangeTable(grid)
def set_change_table(self):
"""Set change table"""
self.change_table = ChangeTable(self.base_grid)
