def test_data_loaded_correctly(self):
"""
Test components initialized with expected data
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: LF_RESERVES_DOWN_ZONE_TIMEPOINTS
req_df = pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs",
"lf_reserves_down_tmp_requirement.tab"),
sep="\t",
)
expected_ba_tmps = sorted(
list(zip(req_df.LOAD_ZONES, req_df.timepoint)))
actual_ba_tmps = sorted([
(z, tmp)
for (z, tmp) in instance.LF_RESERVES_DOWN_ZONES * instance.TMPS
])
self.assertListEqual(expected_ba_tmps, actual_ba_tmps)
# Param: lf_reserves_down_requirement_mw
expected_req = OrderedDict(
sorted(
req_df.set_index(["LOAD_ZONES",
"timepoint"]).to_dict()["load_mw"].items()))
actual_req = OrderedDict(
sorted({
(z, tmp): instance.lf_reserves_down_requirement_mw[z, tmp]
for (z, tmp) in instance.LF_RESERVES_DOWN_ZONES * instance.TMPS
}.items()))
self.assertDictEqual(expected_req, actual_req)
# Param: lf_down_per_req
expected_perc_req = OrderedDict({"Zone1": 0.03, "Zone2": 0})
actual_perc_req = OrderedDict(
sorted({
z: instance.lf_down_per_req[z]
for z in instance.LF_RESERVES_DOWN_ZONES
}.items()))
self.assertDictEqual(expected_perc_req, actual_perc_req)
# Set: LF_DOWN_BA_LZ
expected_ba_lzs = sorted([("Zone1", "Zone1"), ("Zone1", "Zone2"),
("Zone1", "Zone3")])
actual_ba_lzs = sorted([(ba, lz)
for (ba, lz) in instance.LF_DOWN_BA_LZ])
self.assertListEqual(expected_ba_lzs, actual_ba_lzs)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: TX_SPEC_OPR_PRDS
expected_periods = [
("Tx1", 2020),
("Tx1", 2030),
("Tx2", 2020),
("Tx2", 2030),
("Tx3", 2020),
("Tx3", 2030),
]
actual_periods = sorted([(tx, p)
for (tx, p) in instance.TX_SPEC_OPR_PRDS])
self.assertListEqual(expected_periods, actual_periods)
# Param: tx_spec_min_flow_mw
expected_min = OrderedDict(
sorted({
("Tx1", 2020): -10,
("Tx1", 2030): -10,
("Tx2", 2020): -10,
("Tx2", 2030): -10,
("Tx3", 2020): -10,
("Tx3", 2030): -10,
}.items()))
actual_min = OrderedDict(
sorted({(tx, p): instance.tx_spec_min_flow_mw[tx, p]
for (tx, p) in instance.TX_SPEC_OPR_PRDS}.items()))
self.assertDictEqual(expected_min, actual_min)
# Param: specified_tx_max_mw
expected_max = OrderedDict(
sorted({
("Tx1", 2020): 10,
("Tx1", 2030): 10,
("Tx2", 2020): 10,
("Tx2", 2030): 10,
("Tx3", 2020): 10,
("Tx3", 2030): 10,
}.items()))
actual_max = OrderedDict(
sorted({(tx, p): instance.tx_spec_max_flow_mw[tx, p]
for (tx, p) in instance.TX_SPEC_OPR_PRDS}.items()))
self.assertDictEqual(expected_max, actual_max)
def test_data_loaded_correctly(self):
"""
Test components initialized with expected data
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
# Set: FREQUENCY_RESPONSE_BA_TIMEPOINTS
req_df = \
pd.read_csv(
os.path.join(
TEST_DATA_DIRECTORY, "inputs",
"frequency_response_tmp_requirement.tab"
),
sep="\t"
)
expected_ba_tmps = sorted(list(zip(req_df.ba, req_df.timepoint)))
actual_ba_tmps = sorted([
(z, tmp)
for (z, tmp) in instance.FREQUENCY_RESPONSE_BAS * instance.TMPS
])
self.assertListEqual(expected_ba_tmps, actual_ba_tmps)
# Param: frequency_response_requirement_mw
expected_req = OrderedDict(
sorted(
req_df.set_index(['ba', 'timepoint'
]).to_dict()['requirement_mw'].items()))
actual_req = OrderedDict(
sorted({
(z, tmp): instance.frequency_response_requirement_mw[z, tmp]
for (z, tmp) in instance.FREQUENCY_RESPONSE_BAS * instance.TMPS
}.items()))
self.assertDictEqual(expected_req, actual_req)
# Param: frequency_response_partial_requirement_mw
expected_partial_req = OrderedDict(
sorted(
req_df.set_index([
'ba', 'timepoint'
]).to_dict()['partial_requirement_mw'].items()))
actual_partial_req = OrderedDict(
sorted({
(z, tmp):
instance.frequency_response_requirement_partial_mw[z, tmp]
for (z, tmp) in instance.FREQUENCY_RESPONSE_BAS * instance.TMPS
}.items()))
self.assertDictEqual(expected_partial_req, actual_partial_req)
def test_derived_data(self):
"""
Calculations
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: OPR_PRDS_BY_GEN_NEW_BIN_VINTAGE
expected_periods_by_gen_vintage = {
("Gas_CCGT_New_Binary", 2020): [2020, 2030],
("Gas_CCGT_New_Binary", 2030): [2030],
}
actual_periods_by_gen_vintage = {
(prj, vintage): [
period
for period in instance.OPR_PRDS_BY_GEN_NEW_BIN_VINTAGE[prj,
vintage]
]
for (prj, vintage) in instance.OPR_PRDS_BY_GEN_NEW_BIN_VINTAGE
}
self.assertDictEqual(expected_periods_by_gen_vintage,
actual_periods_by_gen_vintage)
# Set: GEN_NEW_BIN_OPR_PRDS
expected_gen_op_periods = [
("Gas_CCGT_New_Binary", 2020),
("Gas_CCGT_New_Binary", 2030),
]
actual_gen_op_periods = sorted([
(prj, period) for (prj, period) in instance.GEN_NEW_BIN_OPR_PRDS
])
self.assertListEqual(expected_gen_op_periods, actual_gen_op_periods)
# Set: GEN_NEW_BIN_VNTS_OPR_IN_PERIOD
expected_gen_vintage_op_in_period = {
2020: [("Gas_CCGT_New_Binary", 2020)],
2030: [("Gas_CCGT_New_Binary", 2020),
("Gas_CCGT_New_Binary", 2030)],
}
actual_gen_vintage_op_in_period = {
p:
[(g, v)
for (g, v) in sorted(instance.GEN_NEW_BIN_VNTS_OPR_IN_PERIOD[p])]
for p in sorted(instance.PERIODS)
}
self.assertDictEqual(expected_gen_vintage_op_in_period,
actual_gen_vintage_op_in_period)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
def test_initialized_components(self):
"""
Create components; check they are initialized with data as expected
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
# Load test data
fuels_df = \
pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs", "fuels.tab"),
sep="\t"
)
fuel_prices_df = \
pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs", "fuel_prices.tab"),
sep="\t"
)
# Set: FUELS
expected_fuels = sorted(fuels_df['FUELS'].tolist())
actual_fuels = sorted([fuel for fuel in instance.FUELS])
self.assertListEqual(expected_fuels, actual_fuels)
# Param: co2_intensity_tons_per_mmbtu
# Rounding to 5 digits here to avoid precision-related error
expected_co2 = OrderedDict(
sorted(
fuels_df.round(5).set_index('FUELS').to_dict()
['co2_intensity_tons_per_mmbtu'].items()))
actual_co2 = OrderedDict(
sorted({
f: instance.co2_intensity_tons_per_mmbtu[f]
for f in instance.FUELS
}.items()))
self.assertDictEqual(expected_co2, actual_co2)
# Param: fuel_price_per_mmbtu
expected_price = OrderedDict(
sorted(
fuel_prices_df.set_index(
['fuel', 'period',
'month']).to_dict()['fuel_price_per_mmbtu'].items()))
actual_price = OrderedDict(
sorted({(f, p, m): instance.fuel_price_per_mmbtu[f, p, m]
for f in instance.FUELS for p in instance.PERIODS
for m in instance.MONTHS}.items()))
self.assertDictEqual(expected_price, actual_price)
def test_initialized_components(self):
"""
Create components; check they are initialized with data as expected
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage=""
)
instance = m.create_instance(data)
# Load test data
# Load test data
market_volume_df = \
pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs",
"market_volume.tab"),
sep="\t"
)
# Param: max_market_sales
expected_max_sales = OrderedDict(
sorted(
market_volume_df.set_index(
['market', 'timepoint']
).to_dict()['max_market_sales'].items()
)
)
actual_max_sales = OrderedDict(sorted(
{(mrkt, tmp): instance.max_market_sales[mrkt, tmp]
for mrkt in instance.MARKETS
for tmp in instance.TMPS}.items()
)
)
self.assertDictEqual(expected_max_sales, actual_max_sales)
# Param: max_market_purchases
expected_max_purchases = OrderedDict(
sorted(
market_volume_df.set_index(
['market', 'timepoint']
).to_dict()['max_market_purchases'].items()
)
)
actual_max_purchases = OrderedDict(sorted(
{(mrkt, tmp): instance.max_market_purchases[mrkt, tmp]
for mrkt in instance.MARKETS
for tmp in instance.TMPS}.items()
)
)
self.assertDictEqual(expected_max_purchases, actual_max_purchases)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: PRM_ZONE_PERIOD_ELCC_SURFACE_FACETS
expected_z_p_f = sorted([
("PRM_Zone1", 2020, 1),
("PRM_Zone1", 2020, 2),
("PRM_Zone1", 2030, 1),
("PRM_Zone1", 2030, 2),
("PRM_Zone2", 2020, 1),
("PRM_Zone2", 2020, 2),
("PRM_Zone2", 2030, 1),
("PRM_Zone2", 2030, 2),
])
actual_z_p_f = sorted([
(z, p, f)
for (z, p, f) in instance.PRM_ZONE_PERIOD_ELCC_SURFACE_FACETS
])
self.assertListEqual(expected_z_p_f, actual_z_p_f)
# Param: elcc_surface_intercept
expected_intercept = OrderedDict(
sorted({
("PRM_Zone1", 2020, 1): 5000,
("PRM_Zone1", 2020, 2): 6000,
("PRM_Zone1", 2030, 1): 10000,
("PRM_Zone1", 2030, 2): 12000,
("PRM_Zone2", 2020, 1): 1000,
("PRM_Zone2", 2020, 2): 1100,
("PRM_Zone2", 2030, 1): 1200,
("PRM_Zone2", 2030, 2): 1300,
}.items()))
actual_intercept = OrderedDict(
sorted({
(z, p, f): instance.elcc_surface_intercept[z, p, f]
for (z, p, f) in instance.PRM_ZONE_PERIOD_ELCC_SURFACE_FACETS
}.items()))
self.assertDictEqual(expected_intercept, actual_intercept)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: GEN_SIMPLE
expected_disp_no_commit_gen_set = sorted(["Disp_No_Commit"])
actual_disp_no_commit_gen_set = sorted(
[prj for prj in instance.GEN_SIMPLE])
self.assertListEqual(expected_disp_no_commit_gen_set,
actual_disp_no_commit_gen_set)
# Set: GEN_SIMPLE_OPR_TMPS
expected_operational_timpoints_by_project = sorted(
get_project_operational_timepoints(
expected_disp_no_commit_gen_set))
actual_operational_timepoints_by_project = sorted([
(g, tmp) for (g, tmp) in instance.GEN_SIMPLE_OPR_TMPS
])
self.assertListEqual(
expected_operational_timpoints_by_project,
actual_operational_timepoints_by_project,
)
# Param: gen_simple_ramp_up_when_on_rate
expected_ramp_up_when_on_rate = {"Disp_No_Commit": 1} # default value
actual_ramp_down_when_on_rate = {
prj: instance.gen_simple_ramp_up_when_on_rate[prj]
for prj in instance.GEN_SIMPLE
}
self.assertDictEqual(expected_ramp_up_when_on_rate,
actual_ramp_down_when_on_rate)
# Param: gen_simple_ramp_down_when_on_rate
expected_ramp_down_when_on_rate = {
"Disp_No_Commit": 1
} # default value
actual_ramp_down_when_on_rate = {
prj: instance.gen_simple_ramp_down_when_on_rate[prj]
for prj in instance.GEN_SIMPLE
}
self.assertDictEqual(expected_ramp_down_when_on_rate,
actual_ramp_down_when_on_rate)
def test_initialized_components(self):
"""
Create components; check they are initialized with data as expected.
Capacity-type modules should have added appropriate data;
make sure it is all as expected.
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: TX_AVL_EXOG_MNTH
expected_tx_subset = sorted(["Tx2"])
actual_tx_subset = sorted([prj for prj in instance.TX_AVL_EXOG_MNTH])
self.assertListEqual(expected_tx_subset, actual_tx_subset)
# Param: availability_derate
availability_df = pd.read_csv(
os.path.join(
TEST_DATA_DIRECTORY,
"inputs",
"transmission_availability_exogenous_monthly.tab",
),
sep="\t",
)
defaults = {(tx, mnth): 1
for tx in instance.TX_AVL_EXOG_MNTH
for mnth in instance.MONTHS}
derates = {(p, tmp): avail
for p, tmp, avail in zip(
availability_df.transmission_line,
availability_df.month,
availability_df.availability_derate,
)}
expected_availability_derate = dict()
for (tx, tmp) in defaults.keys():
if (tx, tmp) in derates.keys():
expected_availability_derate[tx, tmp] = derates[tx, tmp]
else:
expected_availability_derate[tx, tmp] = defaults[tx, tmp]
actual_availability_derate = {(tx, mnth):
instance.tx_avl_exog_mnth_derate[tx,
mnth]
for tx in instance.TX_AVL_EXOG_MNTH
for mnth in instance.MONTHS}
self.assertDictEqual(expected_availability_derate,
actual_availability_derate)
def test_capacity_data_load_correctly(self):
"""
Test that are data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Sets: STOR
expected_projects = ["Battery", "Battery_Binary", "Battery_Specified"]
actual_projects = sorted([p for p in instance.STOR])
self.assertListEqual(expected_projects, actual_projects)
# STOR_OPR_TMPS
expected_tmps = sorted(
get_project_operational_timepoints(expected_projects))
actual_tmps = sorted([tmp for tmp in instance.STOR_OPR_TMPS])
self.assertListEqual(expected_tmps, actual_tmps)
# Param: stor_charging_efficiency
expected_charging_efficiency = {
"Battery": 0.8,
"Battery_Binary": 0.8,
"Battery_Specified": 0.8,
}
actual_charging_efficiency = {
prj: instance.stor_charging_efficiency[prj]
for prj in instance.STOR
}
self.assertDictEqual(expected_charging_efficiency,
actual_charging_efficiency)
# Param: stor_discharging_efficiency
expected_discharging_efficiency = {
"Battery": 0.8,
"Battery_Binary": 0.8,
"Battery_Specified": 0.8,
}
actual_discharging_efficiency = {
prj: instance.stor_discharging_efficiency[prj]
for prj in instance.STOR
}
self.assertDictEqual(expected_discharging_efficiency,
actual_discharging_efficiency)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: GEN_VAR
expected_variable_gen_set = sorted(["Wind", "Wind_z2"])
actual_variable_gen_set = sorted([prj for prj in instance.GEN_VAR])
self.assertListEqual(expected_variable_gen_set, actual_variable_gen_set)
# Set: GEN_VAR_OPR_TMPS
expected_operational_timepoints_by_project = sorted(
get_project_operational_timepoints(expected_variable_gen_set)
)
actual_operational_timepoints_by_project = sorted(
[(g, tmp) for (g, tmp) in instance.GEN_VAR_OPR_TMPS]
)
self.assertListEqual(
expected_operational_timepoints_by_project,
actual_operational_timepoints_by_project,
)
# Param: gen_var_cap_factor
all_df = pd.read_csv(
os.path.join(
TEST_DATA_DIRECTORY, "inputs", "variable_generator_profiles.tab"
),
sep="\t",
)
# We only want projects of the 'gen_var' operational type
v_df = all_df[all_df["project"].isin(expected_variable_gen_set)]
expected_cap_factor = v_df.set_index(["project", "timepoint"]).to_dict()[
"cap_factor"
]
actual_cap_factor = {
(g, tmp): instance.gen_var_cap_factor[g, tmp]
for (g, tmp) in instance.GEN_VAR_OPR_TMPS
}
self.assertDictEqual(expected_cap_factor, actual_cap_factor)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
# Set: RPS_PRJS
expected_rps_projects = sorted(["Wind", "Wind_z2"])
actual_rps_projects = sorted([p for p in instance.RPS_PRJS])
self.assertListEqual(expected_rps_projects, actual_rps_projects)
# Param: rps_zone
expected_rps_zone_by_prj = OrderedDict(
sorted({
"Wind": "RPS_Zone_1",
"Wind_z2": "RPS_Zone_2"
}.items()))
actual_rps_zone_by_prj = OrderedDict(
sorted({p: instance.rps_zone[p]
for p in instance.RPS_PRJS}.items()))
self.assertDictEqual(expected_rps_zone_by_prj, actual_rps_zone_by_prj)
# Set: RPS_PRJS_BY_RPS_ZONE
expected_prj_by_zone = OrderedDict(
sorted({
"RPS_Zone_1": ["Wind"],
"RPS_Zone_2": ["Wind_z2"]
}.items()))
actual_prj_by_zone = OrderedDict(
sorted({
z: [p for p in instance.RPS_PRJS_BY_RPS_ZONE[z]]
for z in instance.RPS_ZONES
}.items()))
self.assertDictEqual(expected_prj_by_zone, actual_prj_by_zone)
# Set: RPS_PRJ_OPR_TMPS
expected_rps_prj_op_tmp = sorted(
get_project_operational_timepoints(expected_rps_projects))
actual_rps_prj_op_tmp = sorted([
(prj, tmp) for (prj, tmp) in instance.RPS_PRJ_OPR_TMPS
])
self.assertListEqual(expected_rps_prj_op_tmp, actual_rps_prj_op_tmp)
def test_regulation_down_zones_data_loads_correctly(self):
"""
Create set and load data; check resulting set is as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=[],
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Balancing areas
expected = sorted(["Zone1", "Zone2"])
actual = sorted([z for z in instance.REGULATION_DOWN_ZONES])
self.assertListEqual(
expected,
actual,
msg="REGULATION_DOWN_ZONES set data does not "
"load correctly.",
)
# Param: allow_violation
expected_allow_violation = OrderedDict(
sorted({
"Zone1": 1,
"Zone2": 1
}.items()))
actual_allow_violation = OrderedDict(
sorted({
z: instance.regulation_down_allow_violation[z]
for z in instance.REGULATION_DOWN_ZONES
}.items()))
self.assertDictEqual(expected_allow_violation, actual_allow_violation)
# Param: violation penalty
expected_penalty = OrderedDict(
sorted({
"Zone1": 99999999,
"Zone2": 99999999
}.items()))
actual_penalty = OrderedDict(
sorted({
z: instance.regulation_down_violation_penalty_per_mw[z]
for z in instance.REGULATION_DOWN_ZONES
}.items()))
self.assertDictEqual(expected_penalty, actual_penalty)
def test_derived_data(self):
"""
Test in-model operations and calculations
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: OPR_PRDS_BY_TX_NEW_LIN_VINTAGE
expected_op_p_by_tx_v = OrderedDict(
sorted({
("Tx_New", 2020): [2020, 2030],
("Tx_New", 2030): [2030]
}.items()))
actual_op_p_by_tx_v = OrderedDict(
sorted({
(tx, v):
[p for p in instance.OPR_PRDS_BY_TX_NEW_LIN_VINTAGE[tx, v]]
for (tx, v) in instance.TX_NEW_LIN_VNTS
}.items()))
self.assertDictEqual(expected_op_p_by_tx_v, actual_op_p_by_tx_v)
# Set: TX_NEW_LIN_OPR_PRDS
expected_tx_op_periods = sorted([("Tx_New", 2020), ("Tx_New", 2030)])
actual_tx_op_periods = sorted([
(tx, p) for (tx, p) in instance.TX_NEW_LIN_OPR_PRDS
])
self.assertListEqual(expected_tx_op_periods, actual_tx_op_periods)
# Set: TX_NEW_LIN_VNTS_OPR_IN_PRD
expected_tx_v_by_period = OrderedDict(
sorted({
2020: sorted([("Tx_New", 2020)]),
2030: sorted([("Tx_New", 2020), ("Tx_New", 2030)]),
}.items()))
actual_tx_v_by_period = OrderedDict(
sorted({
p:
sorted([(tx, v)
for (tx, v) in instance.TX_NEW_LIN_VNTS_OPR_IN_PRD[p]])
for p in instance.PERIODS
}.items()))
self.assertDictEqual(expected_tx_v_by_period, actual_tx_v_by_period)
def test_data_loaded_correctly(self):
"""
:return:
"""
m, data = \
add_components_and_load_data(prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
# Param: import_carbon_tuning_cost
self.assertEqual(instance.import_carbon_tuning_cost_per_ton, 10e-10)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: CARBON_CAP_ZONE_PERIODS_WITH_CARBON_CAP
expected_cc_zone_periods = sorted(
[
("Carbon_Cap_Zone1", 2020),
("Carbon_Cap_Zone1", 2030),
("Carbon_Cap_Zone2", 2020),
("Carbon_Cap_Zone2", 2030),
]
)
actual_cc_zone_periods = sorted(
[(z, p) for (z, p) in instance.CARBON_CAP_ZONE_PERIODS_WITH_CARBON_CAP]
)
self.assertListEqual(expected_cc_zone_periods, actual_cc_zone_periods)
# Param: carbon_cap_target
expected_cc_target = OrderedDict(
sorted(
{
("Carbon_Cap_Zone1", 2020): 50,
("Carbon_Cap_Zone1", 2030): 50,
("Carbon_Cap_Zone2", 2020): 10,
("Carbon_Cap_Zone2", 2030): 10,
}.items()
)
)
actual_cc_target = OrderedDict(
sorted(
{
(z, p): instance.carbon_cap_target[z, p]
for (z, p) in instance.CARBON_CAP_ZONE_PERIODS_WITH_CARBON_CAP
}.items()
)
)
self.assertDictEqual(expected_cc_target, actual_cc_target)
def test_data_loaded_correctly(self):
"""
Test components initialized with expected data
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage=""
)
instance = m.create_instance(data)
# Set: REGULATION_DOWN_ZONE_TIMEPOINTS
req_df = \
pd.read_csv(
os.path.join(
TEST_DATA_DIRECTORY, "inputs",
"regulation_down_tmp_requirement.tab"
),
sep="\t"
)
expected_ba_tmps = sorted(
list(zip(req_df.LOAD_ZONES, req_df.timepoint))
)
actual_ba_tmps = sorted([
(z, tmp) for (z, tmp)
in instance.REGULATION_DOWN_ZONES * instance.TMPS
])
self.assertListEqual(expected_ba_tmps, actual_ba_tmps)
# Param: regulation_down_requirement_mw
expected_req = OrderedDict(
sorted(
req_df.set_index(
['LOAD_ZONES', 'timepoint']
).to_dict()['load_mw'].items()
)
)
actual_req = OrderedDict(sorted({
(z, tmp): instance.regulation_down_requirement_mw[z, tmp]
for (z, tmp) in instance.REGULATION_DOWN_ZONES * instance.TMPS
}.items()
)
)
self.assertDictEqual(expected_req, actual_req)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Params: prm_simple_fraction
expected_prm_frac = OrderedDict(
sorted({
"Coal": 0.8,
"Coal_z2": 0.8,
"Gas_CCGT": 0.8,
"Gas_CCGT_New": 0.8,
"Gas_CCGT_New_Binary": 0.8,
"Gas_CCGT_z2": 0.8,
"Gas_CT": 0.8,
"Gas_CT_New": 0.8,
"Gas_CT_z2": 0.8,
"Nuclear": 0.8,
"Nuclear_z2": 0.8,
"Wind": 0.8,
"Wind_z2": 0.8,
"Battery": 0.8,
"Battery_Binary": 0.8,
"Battery_Specified": 0.8,
"Hydro": 0.8,
"Hydro_NonCurtailable": 0.8,
"Disp_Binary_Commit": 0.8,
"Disp_Cont_Commit": 0.8,
"Disp_No_Commit": 0.8,
"Clunky_Old_Gen": 0.8,
"Clunky_Old_Gen2": 0.8,
"Nuclear_Flexible": 0.8,
}.items()))
actual_prm_frac = OrderedDict(
sorted({
prj: instance.elcc_simple_fraction[prj]
for prj in instance.PRM_PROJECTS
}.items()))
self.assertDictEqual(expected_prm_frac, actual_prm_frac)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: GEN_NEW_BIN_VNTS
expected_gen_vintage_set = sorted([("Gas_CCGT_New_Binary", 2020),
("Gas_CCGT_New_Binary", 2030)])
actual_gen_vintage_set = sorted([
(prj, period) for (prj, period) in instance.GEN_NEW_BIN_VNTS
])
self.assertListEqual(expected_gen_vintage_set, actual_gen_vintage_set)
# Params: gen_new_bin_lifetime_yrs_by_vintage
expected_lifetime = OrderedDict(
sorted({
("Gas_CCGT_New_Binary", 2020): 30,
("Gas_CCGT_New_Binary", 2030): 30,
}.items()))
actual_lifetime = OrderedDict(
sorted({(prj, vintage):
instance.gen_new_bin_lifetime_yrs_by_vintage[prj, vintage]
for (prj, vintage) in instance.GEN_NEW_BIN_VNTS}.items()))
self.assertDictEqual(expected_lifetime, actual_lifetime)
# Params: gen_new_bin_annualized_real_cost_per_mw_yr
expected_cost = OrderedDict(
sorted({
("Gas_CCGT_New_Binary", 2020): 200000,
("Gas_CCGT_New_Binary", 2030): 200000,
}.items()))
actual_cost = OrderedDict(
sorted({
(prj, vintage):
instance.gen_new_bin_annualized_real_cost_per_mw_yr[prj,
vintage]
for (prj, vintage) in instance.GEN_NEW_BIN_VNTS
}.items()))
self.assertDictEqual(expected_cost, actual_cost)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Param: ramp_tuning_cost_per_mw
self.assertEqual(instance.ramp_tuning_cost_per_mw, 10e-10)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: FDDL_PRM_PROJECTS
expected_projects = sorted(
["Battery", "Battery_Binary", "Battery_Specified"])
actual_projects = sorted([prj for prj in instance.FDDL_PRM_PROJECTS])
self.assertListEqual(expected_projects, actual_projects)
# Set: FDDL_PRM_PRJ_OPR_PRDS
expected_proj_period_set = sorted([
("Battery", 2020),
("Battery", 2030),
("Battery_Binary", 2020),
("Battery_Binary", 2030),
("Battery_Specified", 2020),
])
actual_proj_period_set = sorted([
(prj, period) for (prj, period) in instance.FDDL_PRM_PRJ_OPR_PRDS
])
self.assertListEqual(expected_proj_period_set, actual_proj_period_set)
# Param: min_duration_for_full_capacity_credit
expected_dur = OrderedDict(
sorted({
"Battery": 4,
"Battery_Binary": 4,
"Battery_Specified": 4
}.items()))
actual_dur = OrderedDict(
sorted({
p: instance.min_duration_for_full_capacity_credit[p]
for p in instance.FDDL_PRM_PROJECTS
}.items()))
self.assertDictEqual(expected_dur, actual_dur)
def test_derived_data(self):
"""
Calculations
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
# Sets: OPR_PRDS_BY_STOR_NEW_LIN_VINTAGE
expected_op_periods_by_stor_vintage = {
("Battery", 2020): [2020],
("Battery", 2030): [2030]
}
actual_periods_by_stor_vintage = {
(prj, vintage): [
period for period in instance.OPR_PRDS_BY_STOR_NEW_LIN_VINTAGE[
prj, vintage]
]
for (prj, vintage) in instance.OPR_PRDS_BY_STOR_NEW_LIN_VINTAGE
}
self.assertDictEqual(expected_op_periods_by_stor_vintage,
actual_periods_by_stor_vintage)
# Sets: STOR_NEW_LIN_OPR_PRDS
expected_stor_op_periods = sorted([("Battery", 2020),
("Battery", 2030)])
actual_stor_op_periods = sorted([
(prj, period) for (prj, period) in instance.STOR_NEW_LIN_OPR_PRDS
])
self.assertListEqual(expected_stor_op_periods, actual_stor_op_periods)
# Sets: STOR_NEW_LIN_VNTS_OPR_IN_PRD
expected_stor_vintage_op_in_period = {
2020: [("Battery", 2020)],
2030: [("Battery", 2030)]
}
actual_stor_vintage_op_in_period = {
p: [(g, v) for (g, v) in instance.STOR_NEW_LIN_VNTS_OPR_IN_PRD[p]]
for p in instance.PERIODS
}
self.assertDictEqual(expected_stor_vintage_op_in_period,
actual_stor_vintage_op_in_period)
def test_data_loaded_correctly(self):
"""
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Param: hurdle_rate_pos_dir_per_mwh
expected_hurdle_rate_pos = OrderedDict(
sorted([
(("Tx1", 2020), 1.0),
(("Tx1", 2030), 1.0),
(("Tx2", 2020), 0),
(("Tx2", 2030), 0),
(("Tx3", 2020), 0),
(("Tx3", 2030), 0),
(("Tx_New", 2020), 0.0),
(("Tx_New", 2030), 0.0),
]))
actual_hurdle_rate_pos = OrderedDict(
sorted([((tx, p), instance.hurdle_rate_pos_dir_per_mwh[tx, p])
for tx in instance.TX_LINES for p in instance.PERIODS]))
self.assertDictEqual(expected_hurdle_rate_pos, actual_hurdle_rate_pos)
# Param: hurdle_rate_neg_dir_per_mwh
expected_hurdle_rate_neg = OrderedDict(
sorted([
(("Tx1", 2020), 1.0),
(("Tx1", 2030), 1.0),
(("Tx2", 2020), 0),
(("Tx2", 2030), 0),
(("Tx3", 2020), 0),
(("Tx3", 2030), 0),
(("Tx_New", 2020), 0.0),
(("Tx_New", 2030), 0.0),
]))
actual_hurdle_rate_neg = OrderedDict(
sorted([((tx, p), instance.hurdle_rate_neg_dir_per_mwh[tx, p])
for tx in instance.TX_LINES for p in instance.PERIODS]))
self.assertDictEqual(expected_hurdle_rate_neg, actual_hurdle_rate_neg)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: CARBON_CAP_ZONES
expected_carbon_cap_zones = sorted(
["Carbon_Cap_Zone1", "Carbon_Cap_Zone2"])
actual_carbon_cap_zones = sorted(
[z for z in instance.CARBON_CAP_ZONES])
self.assertListEqual(expected_carbon_cap_zones,
actual_carbon_cap_zones)
# Param: allow_violation
expected_allow_violation = OrderedDict(
sorted({
"Carbon_Cap_Zone1": 0,
"Carbon_Cap_Zone2": 0
}.items()))
actual_allow_violation = OrderedDict(
sorted({
z: instance.carbon_cap_allow_violation[z]
for z in instance.CARBON_CAP_ZONES
}.items()))
self.assertDictEqual(expected_allow_violation, actual_allow_violation)
# Param: violation penalty
expected_penalty = OrderedDict(
sorted({
"Carbon_Cap_Zone1": 0,
"Carbon_Cap_Zone2": 0
}.items()))
actual_penalty = OrderedDict(
sorted({
z: instance.carbon_cap_violation_penalty_per_emission[z]
for z in instance.CARBON_CAP_ZONES
}.items()))
self.assertDictEqual(expected_penalty, actual_penalty)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="")
instance = m.create_instance(data)
# Set: PRM_ZONES
expected_markets = sorted(["Market_Hub_1", "Market_Hub_2"])
actual_markets = \
sorted([market for market in instance.MARKETS])
self.assertListEqual(expected_markets, actual_markets)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: PRM_ZONES
expected_prm_zones = sorted(["PRM_Zone1", "PRM_Zone2"])
actual_prm_zones = sorted([z for z in instance.PRM_ZONES])
self.assertListEqual(expected_prm_zones, actual_prm_zones)
def test_data_loaded_correctly(self):
"""
Test that the data loaded are as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: DR
expected_projects = sorted(["Shift_DR"])
actual_always_on_gen_set = sorted([prj for prj in instance.DR])
self.assertListEqual(expected_projects, actual_always_on_gen_set)
# Set: DR_OPERATIONAL_TIMEPOINTS
expected_operational_timpoints_by_project = sorted(
get_project_operational_timepoints(expected_projects))
actual_operational_timepoints_by_project = sorted([
(g, tmp) for (g, tmp) in instance.DR_OPR_TMPS
])
self.assertListEqual(
expected_operational_timpoints_by_project,
actual_operational_timepoints_by_project,
)
# Set: DR_OPERATIONAL_HORIZONS
expected_operational_horizons_by_project = sorted([
("Shift_DR", 202001),
("Shift_DR", 202002),
("Shift_DR", 203001),
("Shift_DR", 203002),
])
actual_operational_horizons_by_project = sorted([
(g, tmp) for (g, tmp) in instance.DR_OPR_HRZS
])
self.assertListEqual(
expected_operational_horizons_by_project,
actual_operational_horizons_by_project,
)
def test_data_loaded_correctly(self):
"""
Test components initialized with data as expected
:return:
"""
m, data = add_components_and_load_data(
prereq_modules=IMPORTED_PREREQ_MODULES,
module_to_test=MODULE_BEING_TESTED,
test_data_dir=TEST_DATA_DIRECTORY,
subproblem="",
stage="",
)
instance = m.create_instance(data)
# Set: LOCAL_CAPACITY_ZONE_PERIODS_WITH_REQUIREMENT
expected_zone_periods = sorted([
("Local_Capacity_Zone1", 2020),
("Local_Capacity_Zone1", 2030),
("Local_Capacity_Zone2", 2020),
("Local_Capacity_Zone2", 2030),
])
actual_zone_periods = sorted([
(z, p)
for (z, p) in instance.LOCAL_CAPACITY_ZONE_PERIODS_WITH_REQUIREMENT
])
self.assertListEqual(expected_zone_periods, actual_zone_periods)
# Param: local_capacity_target_mmt
expected_target = OrderedDict(
sorted({
("Local_Capacity_Zone1", 2020): 60,
("Local_Capacity_Zone1", 2030): 60,
("Local_Capacity_Zone2", 2020): 60,
("Local_Capacity_Zone2", 2030): 60,
}.items()))
actual_target = OrderedDict(
sorted({
(z, p): instance.local_capacity_requirement_mw[z, p]
for (
z,
p) in instance.LOCAL_CAPACITY_ZONE_PERIODS_WITH_REQUIREMENT
}.items()))
self.assertDictEqual(expected_target, actual_target)
