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_MUST_RUN
expected_gen_must_run_gen_set = sorted(["Nuclear", "Nuclear_z2"])
actual_gen_must_run_gen_set = sorted([prj for prj in instance.GEN_MUST_RUN])
self.assertListEqual(expected_gen_must_run_gen_set, actual_gen_must_run_gen_set)
# Set: GEN_MUST_RUN_OPR_TMPS
expected_operational_timpoints_by_project = sorted(
get_project_operational_timepoints(expected_gen_must_run_gen_set)
)
actual_operational_timepoints_by_project = sorted(
[(g, tmp) for (g, tmp) in instance.GEN_MUST_RUN_OPR_TMPS]
)
self.assertListEqual(
expected_operational_timpoints_by_project,
actual_operational_timepoints_by_project,
)
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_MUST_TAKE
expected_gen_set = sorted([
"Customer_PV"
])
actual_gen_set = sorted([
prj for prj in instance.GEN_VAR_MUST_TAKE
])
self.assertListEqual(expected_gen_set,
actual_gen_set)
# Set: VARIABLE_GENERATOR_OPERATIONAL_TIMEPOINTS
expected_operational_timepoints_by_project = sorted(
get_project_operational_timepoints(expected_gen_set)
)
actual_operational_timepoints_by_project = sorted(
[(g, tmp) for (g, tmp) in
instance.
GEN_VAR_MUST_TAKE_OPR_TMPS]
)
self.assertListEqual(expected_operational_timepoints_by_project,
actual_operational_timepoints_by_project)
# Param: gen_var_must_take_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_must_take' operational
# type
vnc_df = all_df[all_df["project"].isin(expected_gen_set)]
expected_cap_factor = \
vnc_df.set_index(['project', 'timepoint']).to_dict()['cap_factor']
actual_cap_factor = {
(g, tmp): instance.gen_var_must_take_cap_factor[g, tmp]
for (g, tmp) in
instance.GEN_VAR_MUST_TAKE_OPR_TMPS
}
self.assertDictEqual(expected_cap_factor, actual_cap_factor)
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_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_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_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: 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 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_COMMIT_CAP
expected_disp_cap_commit_gen_set = sorted([
"Gas_CCGT",
"Coal",
"Gas_CT",
"Gas_CCGT_New",
"Gas_CCGT_New_Binary",
"Gas_CT_New",
"Gas_CCGT_z2",
"Coal_z2",
"Gas_CT_z2",
])
actual_disp_cap_commit_gen_set = sorted(
[prj for prj in instance.GEN_COMMIT_CAP])
self.assertListEqual(expected_disp_cap_commit_gen_set,
actual_disp_cap_commit_gen_set)
# Set: GEN_COMMIT_CAP_OPR_TMPS
expected_operational_timpoints_by_project = sorted(
get_project_operational_timepoints(
expected_disp_cap_commit_gen_set))
actual_operational_timepoints_by_project = sorted([
(g, tmp) for (g, tmp) in instance.GEN_COMMIT_CAP_OPR_TMPS
])
self.assertListEqual(
expected_operational_timpoints_by_project,
actual_operational_timepoints_by_project,
)
# Param: gen_commit_cap_unit_size_mw
expected_unit_size = {
"Gas_CCGT": 6,
"Coal": 6,
"Gas_CT": 6,
"Gas_CCGT_New": 6,
"Gas_CCGT_New_Binary": 6,
"Gas_CT_New": 6,
"Gas_CCGT_z2": 6,
"Coal_z2": 6,
"Gas_CT_z2": 6,
}
actual_unit_size = {
prj: instance.gen_commit_cap_unit_size_mw[prj]
for prj in instance.GEN_COMMIT_CAP
}
self.assertDictEqual(expected_unit_size, actual_unit_size)
# Param: gen_commit_cap_min_stable_level_fraction
expected_min_stable_fraction = {
"Gas_CCGT": 0.4,
"Coal": 0.4,
"Gas_CT": 0.4,
"Gas_CCGT_New": 0.4,
"Gas_CCGT_New_Binary": 0.4,
"Gas_CT_New": 0.4,
"Gas_CCGT_z2": 0.4,
"Coal_z2": 0.4,
"Gas_CT_z2": 0.4,
}
actual_min_stable_fraction = {
prj: instance.gen_commit_cap_min_stable_level_fraction[prj]
for prj in instance.GEN_COMMIT_CAP
}
self.assertDictEqual(expected_min_stable_fraction,
actual_min_stable_fraction)
# Param: gen_commit_cap_startup_plus_ramp_up_rate
expected_startup_plus_ramp_up_rate = {
"Gas_CCGT": 0.6,
"Coal": 0.6,
"Gas_CT": 0.6,
"Gas_CCGT_New": 0.6,
"Gas_CCGT_New_Binary": 0.6,
"Gas_CT_New": 0.6,
"Gas_CCGT_z2": 1,
"Coal_z2": 1,
"Gas_CT_z2": 1,
}
actual_startup_plus_ramp_up_rate = {
prj: instance.gen_commit_cap_startup_plus_ramp_up_rate[prj]
for prj in instance.GEN_COMMIT_CAP
}
self.assertDictEqual(expected_startup_plus_ramp_up_rate,
actual_startup_plus_ramp_up_rate)
# Param: gen_commit_cap_shutdown_plus_ramp_down_rate
expected_shutdown_plus_ramp_down_rate = {
"Gas_CCGT": 0.6,
"Coal": 0.6,
"Gas_CT": 0.6,
"Gas_CCGT_New": 0.6,
"Gas_CCGT_New_Binary": 0.6,
"Gas_CT_New": 0.6,
"Gas_CCGT_z2": 1,
"Coal_z2": 1,
"Gas_CT_z2": 1,
}
actual_shutdown_plus_ramp_down_rate = {
prj: instance.gen_commit_cap_shutdown_plus_ramp_down_rate[prj]
for prj in instance.GEN_COMMIT_CAP
}
self.assertDictEqual(expected_shutdown_plus_ramp_down_rate,
actual_shutdown_plus_ramp_down_rate)
# Param: gen_commit_cap_ramp_up_when_on_rate
expected_ramp_up_when_on_rate = {
"Gas_CCGT": 0.3,
"Coal": 0.2,
"Gas_CT": 0.5,
"Gas_CCGT_New": 0.5,
"Gas_CCGT_New_Binary": 0.5,
"Gas_CT_New": 0.8,
"Gas_CCGT_z2": 1,
"Coal_z2": 1,
"Gas_CT_z2": 1,
}
actual_ramp_down_when_on_rate = {
prj: instance.gen_commit_cap_ramp_up_when_on_rate[prj]
for prj in instance.GEN_COMMIT_CAP
}
self.assertDictEqual(expected_ramp_up_when_on_rate,
actual_ramp_down_when_on_rate)
# Param: gen_commit_cap_ramp_down_when_on_rate
expected_ramp_down_when_on_rate = {
"Gas_CCGT": 0.5,
"Coal": 0.3,
"Gas_CT": 0.2,
"Gas_CCGT_New": 0.8,
"Gas_CCGT_New_Binary": 0.8,
"Gas_CT_New": 0.5,
"Gas_CCGT_z2": 1,
"Coal_z2": 1,
"Gas_CT_z2": 1,
}
actual_ramp_down_when_on_rate = {
prj: instance.gen_commit_cap_ramp_down_when_on_rate[prj]
for prj in instance.GEN_COMMIT_CAP
}
self.assertDictEqual(expected_ramp_down_when_on_rate,
actual_ramp_down_when_on_rate)
# Param: gen_commit_cap_min_up_time_hours
expected_min_up_time = OrderedDict(
sorted({
"Gas_CCGT": 3,
"Coal": 2,
"Gas_CT": 5,
"Gas_CCGT_New": 8,
"Gas_CCGT_New_Binary": 8,
"Gas_CT_New": 5,
"Gas_CCGT_z2": 1,
"Coal_z2": 1,
"Gas_CT_z2": 1,
}.items()))
actual_min_up_time = OrderedDict(
sorted({
prj: instance.gen_commit_cap_min_up_time_hours[prj]
for prj in instance.GEN_COMMIT_CAP
}.items()))
self.assertDictEqual(expected_min_up_time, actual_min_up_time)
# Param: gen_commit_cap_min_down_time_hours
expected_min_down_time = OrderedDict(
sorted({
"Gas_CCGT": 7,
"Coal": 10,
"Gas_CT": 3,
"Gas_CCGT_New": 5,
"Gas_CCGT_New_Binary": 5,
"Gas_CT_New": 2,
"Gas_CCGT_z2": 1,
"Coal_z2": 1,
"Gas_CT_z2": 1,
}.items()))
actual_min_down_time = OrderedDict(
sorted({
prj: instance.gen_commit_cap_min_down_time_hours[prj]
for prj in instance.GEN_COMMIT_CAP
}.items()))
self.assertDictEqual(expected_min_down_time, actual_min_down_time)
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: GEN_HYDRO_MUST_TAKE
expected_projects = ["Hydro_NonCurtailable"]
actual_projects = [p for p in instance.GEN_HYDRO_MUST_TAKE]
self.assertListEqual(expected_projects, actual_projects)
# Sets: GEN_HYDRO_MUST_TAKE_OPR_HRZS
expected_operational_horizons = sorted(
[("Hydro_NonCurtailable", 2020), ("Hydro_NonCurtailable", 2030)]
)
actual_operational_horizons = sorted(
[p for p in instance.GEN_HYDRO_MUST_TAKE_OPR_HRZS]
)
self.assertListEqual(expected_operational_horizons, actual_operational_horizons)
# Param: gen_hydro_must_take_average_power_fraction
expected_average_power = OrderedDict(
sorted(
{
("Hydro_NonCurtailable", 2020): 0.5,
("Hydro_NonCurtailable", 2030): 0.5,
}.items()
)
)
actual_average_power = OrderedDict(
sorted(
{
(prj, period): instance.gen_hydro_must_take_average_power_fraction[
prj, period
]
for (prj, period) in instance.GEN_HYDRO_MUST_TAKE_OPR_HRZS
}.items()
)
)
self.assertDictEqual(expected_average_power, actual_average_power)
# Param: gen_hydro_must_take_min_power_fraction
expected_min_power = OrderedDict(
sorted(
{
("Hydro_NonCurtailable", 2020): 0.15,
("Hydro_NonCurtailable", 2030): 0.15,
}.items()
)
)
actual_min_power = OrderedDict(
sorted(
{
(prj, period): instance.gen_hydro_must_take_min_power_fraction[
prj, period
]
for (prj, period) in instance.GEN_HYDRO_MUST_TAKE_OPR_HRZS
}.items()
)
)
self.assertDictEqual(expected_min_power, actual_min_power)
# Param: gen_hydro_must_take_max_power_fraction
expected_max_power = OrderedDict(
sorted(
{
("Hydro_NonCurtailable", 2020): 1,
("Hydro_NonCurtailable", 2030): 1,
}.items()
)
)
actual_max_power = OrderedDict(
sorted(
{
(prj, period): instance.gen_hydro_must_take_max_power_fraction[
prj, period
]
for (prj, period) in instance.GEN_HYDRO_MUST_TAKE_OPR_HRZS
}.items()
)
)
self.assertDictEqual(expected_max_power, actual_max_power)
# GEN_HYDRO_MUST_TAKE_OPR_TMPS
expected_tmps = sorted(get_project_operational_timepoints(expected_projects))
actual_tmps = sorted([tmp for tmp in instance.GEN_HYDRO_MUST_TAKE_OPR_TMPS])
self.assertListEqual(expected_tmps, actual_tmps)
# Param: gen_hydro_must_take_ramp_up_when_on_rate
expected_ramp_up = OrderedDict(sorted({"Hydro_NonCurtailable": 0.5}.items()))
actual_ramp_up = OrderedDict(
sorted(
{
prj: instance.gen_hydro_must_take_ramp_up_when_on_rate[prj]
for prj in instance.GEN_HYDRO_MUST_TAKE
}.items()
)
)
self.assertDictEqual(expected_ramp_up, actual_ramp_up)
# Param: gen_hydro_must_take_ramp_down_when_on_rate
expected_ramp_down = OrderedDict(sorted({"Hydro_NonCurtailable": 0.5}.items()))
actual_ramp_down = OrderedDict(
sorted(
{
prj: instance.gen_hydro_must_take_ramp_down_when_on_rate[prj]
for prj in instance.GEN_HYDRO_MUST_TAKE
}.items()
)
)
self.assertDictEqual(expected_ramp_down, actual_ramp_down)
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_COMMIT_BIN
expected_disp_bin_commit_gen_set = sorted(["Disp_Binary_Commit"])
actual_disp_bin_commit_gen_set = sorted(
[prj for prj in instance.GEN_COMMIT_BIN])
self.assertListEqual(expected_disp_bin_commit_gen_set,
actual_disp_bin_commit_gen_set)
# Set: GEN_COMMIT_BIN_STARTUP_BY_ST_PRJS
expected_gen_commit_bin_str_rmp_prjs = sorted(["Disp_Binary_Commit"])
actual_gen_commit_bin_str_rmp_prjs = sorted(
[prj for prj in instance.GEN_COMMIT_BIN_STARTUP_BY_ST_PRJS])
self.assertListEqual(expected_gen_commit_bin_str_rmp_prjs,
actual_gen_commit_bin_str_rmp_prjs)
# Set: GEN_COMMIT_BIN_STARTUP_BY_ST_PRJS_TYPES
expected_gen_commit_bin_str_rmp_prjs_types = sorted([
("Disp_Binary_Commit", 1.0)
])
actual_gen_commit_bin_str_rmp_prjs_types = sorted([
(prj, s)
for prj, s in instance.GEN_COMMIT_BIN_STARTUP_BY_ST_PRJS_TYPES
])
self.assertListEqual(expected_gen_commit_bin_str_rmp_prjs_types,
actual_gen_commit_bin_str_rmp_prjs_types)
# Set: GEN_COMMIT_BIN_STR_TYPES_BY_PRJ
str_types_by_prj_dict = dict()
for prj_type in expected_gen_commit_bin_str_rmp_prjs_types:
if prj_type[0] not in str_types_by_prj_dict.keys():
str_types_by_prj_dict[prj_type[0]] = [prj_type[1]]
else:
str_types_by_prj_dict[prj_type[0]].append(prj_type[1])
expected_str_types_by_prj = OrderedDict(
sorted(str_types_by_prj_dict.items()))
actual_str_types_by_prj = OrderedDict(
sorted({
prj: [
type
for type in instance.GEN_COMMIT_BIN_STR_TYPES_BY_PRJ[prj]
]
for prj in instance.GEN_COMMIT_BIN_STARTUP_BY_ST_PRJS
}.items()))
self.assertDictEqual(expected_str_types_by_prj,
actual_str_types_by_prj)
# Set: GEN_COMMIT_BIN_OPR_TMPS
expected_operational_timepoints_by_project = sorted(
get_project_operational_timepoints(
expected_disp_bin_commit_gen_set))
actual_operational_timepoints_by_project = sorted([
(g, tmp) for (g, tmp) in instance.GEN_COMMIT_BIN_OPR_TMPS
])
self.assertListEqual(expected_operational_timepoints_by_project,
actual_operational_timepoints_by_project)
# Set: GEN_COMMIT_BIN_OPR_TMPS_STR_TYPES
expected_opr_tmps_str_types = sorted([
(g, tmp, 1.0)
for (g, tmp) in expected_operational_timepoints_by_project
if g in expected_gen_commit_bin_str_rmp_prjs
])
actual_opr_tmps_str_types = sorted([
(g, tmp, s)
for (g, tmp, s) in instance.GEN_COMMIT_BIN_OPR_TMPS_STR_TYPES
])
self.assertListEqual(expected_opr_tmps_str_types,
actual_opr_tmps_str_types)
# Param: gen_commit_bin_min_stable_level_fraction
expected_min_stable_fraction = {"Disp_Binary_Commit": 0.4}
actual_min_stable_fraction = {
prj: instance.gen_commit_bin_min_stable_level_fraction[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_min_stable_fraction,
actual_min_stable_fraction)
# Param: gen_commit_bin_startup_plus_ramp_up_rate_by_st
expected_startup_plus_ramp_up_rate_by_st = {
("Disp_Binary_Commit", 1.0): 0.6
}
actual_startup_plus_ramp_up_rate_by_st = {
(prj, s):
instance.gen_commit_bin_startup_plus_ramp_up_rate_by_st[prj, s]
for prj, s in instance.GEN_COMMIT_BIN_STARTUP_BY_ST_PRJS_TYPES
}
self.assertDictEqual(expected_startup_plus_ramp_up_rate_by_st,
actual_startup_plus_ramp_up_rate_by_st)
# Param: gen_commit_bin_shutdown_plus_ramp_down_rate
expected_shutdown_plus_ramp_down_rate = {"Disp_Binary_Commit": 0.6}
actual_shutdown_plus_ramp_down_rate = {
prj: instance.gen_commit_bin_shutdown_plus_ramp_down_rate[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_shutdown_plus_ramp_down_rate,
actual_shutdown_plus_ramp_down_rate)
# Param: gen_commit_bin_ramp_up_when_on_rate
expected_ramp_up_when_on_rate = {"Disp_Binary_Commit": 0.3}
actual_ramp_down_when_on_rate = {
prj: instance.gen_commit_bin_ramp_up_when_on_rate[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_ramp_up_when_on_rate,
actual_ramp_down_when_on_rate)
# Param: gen_commit_bin_ramp_down_when_on_rate
expected_ramp_down_when_on_rate = {"Disp_Binary_Commit": 0.5}
actual_ramp_down_when_on_rate = {
prj: instance.gen_commit_bin_ramp_down_when_on_rate[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_ramp_down_when_on_rate,
actual_ramp_down_when_on_rate)
# Param: gen_commit_bin_ramp_down_when_on_rate
expected_ramp_down_when_on_rate = {"Disp_Binary_Commit": 0.5}
actual_ramp_down_when_on_rate = {
prj: instance.gen_commit_bin_ramp_down_when_on_rate[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_ramp_down_when_on_rate,
actual_ramp_down_when_on_rate)
# Param: gen_commit_bin_allow_ramp_up_violation
expected_ramp_up_viol = {"Disp_Binary_Commit": 1.0}
actual_ramp_up_viol = {
prj: instance.gen_commit_bin_allow_ramp_up_violation[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_ramp_up_viol, actual_ramp_up_viol)
# Param: gen_commit_bin_allow_ramp_down_violation
expected_ramp_down_viol = {"Disp_Binary_Commit": 0}
actual_ramp_down_viol = {
prj: instance.gen_commit_bin_allow_ramp_down_violation[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_ramp_down_viol, actual_ramp_down_viol)
# Param: gen_commit_bin_min_up_time_hours
expected_min_up_time = {"Disp_Binary_Commit": 3}
actual_min_up_time = {
prj: instance.gen_commit_bin_min_up_time_hours[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_min_up_time, actual_min_up_time)
# Param: gen_commit_bin_allow_min_up_time_violation
expected_min_up_time_viol = {"Disp_Binary_Commit": 1.0}
actual_min_up_time_viol = {
prj: instance.gen_commit_bin_allow_min_up_time_violation[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_min_up_time_viol,
actual_min_up_time_viol)
# Param: gen_commit_bin_min_down_time_hours
expected_min_down_time = {"Disp_Binary_Commit": 7}
actual_min_down_time = {
prj: instance.gen_commit_bin_min_down_time_hours[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_min_down_time, actual_min_down_time)
# Param: gen_commit_bin_allow_min_down_time_violation
expected_min_down_time_viol = {"Disp_Binary_Commit": 0.0}
actual_min_down_time_viol = {
prj: instance.gen_commit_bin_allow_min_down_time_violation[prj]
for prj in instance.GEN_COMMIT_BIN
}
self.assertDictEqual(expected_min_down_time_viol,
actual_min_down_time_viol)
# Param: gen_commit_bin_down_time_cutoff_hours
expected_down_time_cutoff_hours = {("Disp_Binary_Commit", 1.0): 7}
actual_down_time_cutoff_hours = {
(prj, s): instance.gen_commit_bin_down_time_cutoff_hours[prj, s]
for prj, s in instance.GEN_COMMIT_BIN_STARTUP_BY_ST_PRJS_TYPES
}
self.assertDictEqual(expected_down_time_cutoff_hours,
actual_down_time_cutoff_hours)
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: AVL_CONT
expected_project_subset = sorted([
"Gas_CT"
])
actual_project_subset = sorted([
prj for prj in instance.AVL_CONT
])
self.assertListEqual(expected_project_subset,
actual_project_subset)
# Set: AVL_CONT_OPR_TMPS
expected_operational_timpoints_by_project = sorted(
get_project_operational_timepoints(expected_project_subset)
)
actual_operational_timepoints_by_project = sorted(
[(g, tmp) for (g, tmp) in
instance.AVL_CONT_OPR_TMPS]
)
self.assertListEqual(expected_operational_timpoints_by_project,
actual_operational_timepoints_by_project)
# Param: avl_cont_unavl_hrs_per_prd
expected_unavailable_hours_per_period = get_endogenous_params(
test_data_directory=TEST_DATA_DIRECTORY,
param="unavailable_hours_per_period",
project_subset=actual_project_subset
)
actual_unavailable_hours_per_period = {
prj: instance.avl_cont_unavl_hrs_per_prd[prj]
for prj in instance.AVL_CONT
}
self.assertDictEqual(expected_unavailable_hours_per_period,
actual_unavailable_hours_per_period)
# Param: avl_cont_min_unavl_hrs_per_event
expected_unavailable_hours_per_event = get_endogenous_params(
test_data_directory=TEST_DATA_DIRECTORY,
param="unavailable_hours_per_event_min",
project_subset=actual_project_subset
)
actual_unavailable_hours_per_event = {
prj: instance.avl_cont_min_unavl_hrs_per_event[prj]
for prj in instance.AVL_CONT
}
self.assertDictEqual(expected_unavailable_hours_per_event,
actual_unavailable_hours_per_event)
# Param: avl_cont_min_avl_hrs_between_events
expected_unavailable_hours_per_event = get_endogenous_params(
test_data_directory=TEST_DATA_DIRECTORY,
param="available_hours_between_events_min",
project_subset=actual_project_subset
)
actual_unavailable_hours_per_event = {
prj: instance.avl_cont_min_avl_hrs_between_events[prj]
for prj in instance.AVL_CONT
}
self.assertDictEqual(expected_unavailable_hours_per_event,
actual_unavailable_hours_per_event)
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)
# Load test data as dataframes
projects_df = pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs", "projects.tab"), sep="\t"
)
hr_curve_df = pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs", "heat_rate_curves.tab"),
sep="\t",
)
timepoints_df = pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs", "timepoints.tab"),
sep="\t",
usecols=["timepoint", "period"],
)
# Set: FUEL_PRJ_OPR_TMPS
expected_fuel_projects = sorted(
projects_df[projects_df["fuel"] != "."]["project"].tolist()
)
expected_fuel_prj_tmps = get_project_operational_timepoints(
expected_fuel_projects
)
actual_fuel_prj_tmps = sorted(
[(p, tmp) for (p, tmp) in instance.FUEL_PRJ_OPR_TMPS]
)
self.assertListEqual(expected_fuel_prj_tmps, actual_fuel_prj_tmps)
# Set: HR_CURVE_PRJS_OPR_TMPS
expected_hr_curve_projects = sorted(hr_curve_df["project"].unique().tolist())
expected_hr_curve_prj_tmps = get_project_operational_timepoints(
expected_hr_curve_projects
)
actual_hr_curve_prj_tmps = sorted(
[(p, tmp) for (p, tmp) in instance.HR_CURVE_PRJS_OPR_TMPS]
)
self.assertListEqual(expected_hr_curve_prj_tmps, actual_hr_curve_prj_tmps)
# Set: HR_CURVE_PRJS_OPR_TMPS_SGMS
expected_segments_by_prj_period = {
("Coal", 2020): [0],
("Coal", 2030): [0],
("Gas_CCGT", 2020): [0],
("Gas_CCGT", 2030): [0],
("Gas_CT", 2020): [0],
("Gas_CT", 2030): [0],
("Nuclear", 2020): [0],
("Nuclear", 2030): [0],
("Gas_CCGT_New", 2020): [0],
("Gas_CCGT_New", 2030): [0],
("Gas_CCGT_New_Binary", 2020): [0],
("Gas_CCGT_New_Binary", 2030): [0],
("Gas_CT_New", 2020): [0],
("Gas_CT_New", 2030): [0],
("Coal_z2", 2020): [0],
("Coal_z2", 2030): [0],
("Gas_CCGT_z2", 2020): [0],
("Gas_CCGT_z2", 2030): [0],
("Gas_CT_z2", 2020): [0],
("Gas_CT_z2", 2030): [0],
("Nuclear_z2", 2020): [0],
("Nuclear_z2", 2030): [0],
("Disp_Binary_Commit", 2020): [0],
("Disp_Binary_Commit", 2030): [0],
("Disp_Cont_Commit", 2020): [0],
("Disp_Cont_Commit", 2030): [0],
("Disp_No_Commit", 2020): [0],
("Disp_No_Commit", 2030): [0],
("Clunky_Old_Gen", 2020): [0],
("Clunky_Old_Gen", 2030): [0],
("Clunky_Old_Gen2", 2020): [0],
("Clunky_Old_Gen2", 2030): [0],
("Nuclear_Flexible", 2020): [0],
("Nuclear_Flexible", 2030): [0],
}
expected_hr_curve_prj_tmp_sgms = list()
for (prj, tmp) in expected_hr_curve_prj_tmps:
prd = timepoints_df[timepoints_df["timepoint"] == tmp].iloc[0]["period"]
segments = expected_segments_by_prj_period[prj, prd]
for sgm in segments:
expected_hr_curve_prj_tmp_sgms.append((prj, tmp, sgm))
actual_hr_curve_prj_tmp_sgms = sorted(
[
(prj, tmp, sgm)
for (prj, tmp, sgm) in instance.HR_CURVE_PRJS_OPR_TMPS_SGMS
]
)
self.assertListEqual(
expected_hr_curve_prj_tmp_sgms, actual_hr_curve_prj_tmp_sgms
)
# Set: STARTUP_FUEL_PRJ_OPR_TMPS
expected_startup_fuel_projects = sorted(
projects_df[projects_df["startup_fuel_mmbtu_per_mw"] != "."][
"project"
].tolist()
)
expected_startup_fuel_prj_tmps = get_project_operational_timepoints(
expected_startup_fuel_projects
)
actual_startup_fuel_prj_tmps = sorted(
[(p, tmp) for (p, tmp) in instance.STARTUP_FUEL_PRJ_OPR_TMPS]
)
self.assertListEqual(
expected_startup_fuel_prj_tmps, actual_startup_fuel_prj_tmps
)
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: AVL_EXOG
expected_project_subset = sorted([
"Nuclear", "Coal", "Wind", "Gas_CCGT_New", "Gas_CCGT_New_Binary",
"Gas_CT_New", "Nuclear_z2", "Gas_CCGT_z2", "Coal_z2", "Gas_CT_z2",
"Wind_z2", "Battery", "Battery_Binary", "Battery_Specified",
"Hydro", "Hydro_NonCurtailable",
"Disp_Binary_Commit", "Disp_Cont_Commit", "Disp_No_Commit",
"Clunky_Old_Gen", "Clunky_Old_Gen2",
"Customer_PV", "Nuclear_Flexible", "Shift_DR"
])
actual_project_subset = sorted([
prj for prj in instance.AVL_EXOG
])
self.assertListEqual(expected_project_subset,
actual_project_subset)
# Set: AVL_EXOG_OPR_TMPS
expected_operational_timepoints_by_project = sorted(
get_project_operational_timepoints(expected_project_subset)
)
actual_operational_timepoints_by_project = sorted(
[(g, tmp) for (g, tmp) in
instance.AVL_EXOG_OPR_TMPS]
)
self.assertListEqual(expected_operational_timepoints_by_project,
actual_operational_timepoints_by_project)
# Param: availability_derate
availability_df = pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs",
"project_availability_exogenous.tab"),
sep="\t"
)
defaults = {
(p, tmp): 1
for (p, tmp) in
instance.AVL_EXOG_OPR_TMPS
}
derates = {
(p, tmp): avail for p, tmp, avail
in zip(availability_df.project, availability_df.timepoint,
availability_df.availability_derate)
}
expected_availability_derate = dict()
for (p, tmp) in defaults.keys():
if (p, tmp) in derates.keys():
expected_availability_derate[p, tmp] = derates[p, tmp]
else:
expected_availability_derate[p, tmp] = defaults[p, tmp]
actual_availability_derate = {
(prj, tmp): instance.avl_exog_derate[prj, tmp]
for (prj, tmp) in
instance.AVL_EXOG_OPR_TMPS
}
self.assertDictEqual(expected_availability_derate,
actual_availability_derate)
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: CRBN_PRJS
expected_carbonaceous_projects = sorted([
"Gas_CCGT",
"Coal",
"Gas_CT",
"Gas_CCGT_New",
"Gas_CCGT_New_Binary",
"Gas_CT_New",
"Gas_CCGT_z2",
"Coal_z2",
"Gas_CT_z2",
"Disp_Binary_Commit",
"Disp_Cont_Commit",
"Disp_No_Commit",
"Clunky_Old_Gen",
"Clunky_Old_Gen2",
])
actual_carbonaceous_projects = sorted([p for p in instance.CRBN_PRJS])
self.assertListEqual(expected_carbonaceous_projects,
actual_carbonaceous_projects)
# Param: carbon_cap_zone
expected_cc_zone_by_prj = OrderedDict(
sorted({
"Gas_CCGT": "Carbon_Cap_Zone1",
"Coal": "Carbon_Cap_Zone1",
"Gas_CT": "Carbon_Cap_Zone1",
"Gas_CCGT_New": "Carbon_Cap_Zone1",
"Gas_CCGT_New_Binary": "Carbon_Cap_Zone1",
"Gas_CT_New": "Carbon_Cap_Zone1",
"Gas_CCGT_z2": "Carbon_Cap_Zone2",
"Coal_z2": "Carbon_Cap_Zone2",
"Gas_CT_z2": "Carbon_Cap_Zone2",
"Disp_Binary_Commit": "Carbon_Cap_Zone1",
"Disp_Cont_Commit": "Carbon_Cap_Zone1",
"Disp_No_Commit": "Carbon_Cap_Zone1",
"Clunky_Old_Gen": "Carbon_Cap_Zone1",
"Clunky_Old_Gen2": "Carbon_Cap_Zone1",
}.items()))
actual_cc_zone_by_prj = OrderedDict(
sorted(
{p: instance.carbon_cap_zone[p]
for p in instance.CRBN_PRJS}.items()))
self.assertDictEqual(expected_cc_zone_by_prj, actual_cc_zone_by_prj)
# Set: CRBN_PRJS_BY_CARBON_CAP_ZONE
expected_prj_by_zone = OrderedDict(
sorted({
"Carbon_Cap_Zone1":
sorted([
"Gas_CCGT",
"Coal",
"Gas_CT",
"Gas_CCGT_New",
"Gas_CCGT_New_Binary",
"Gas_CT_New",
"Disp_Binary_Commit",
"Disp_Cont_Commit",
"Disp_No_Commit",
"Clunky_Old_Gen",
"Clunky_Old_Gen2",
]),
"Carbon_Cap_Zone2":
sorted(["Gas_CCGT_z2", "Coal_z2", "Gas_CT_z2"]),
}.items()))
actual_prj_by_zone = OrderedDict(
sorted({
z:
sorted([p for p in instance.CRBN_PRJS_BY_CARBON_CAP_ZONE[z]])
for z in instance.CARBON_CAP_ZONES
}.items()))
self.assertDictEqual(expected_prj_by_zone, actual_prj_by_zone)
# Set: CRBN_PRJ_OPR_TMPS
expected_carb_prj_op_tmp = sorted(
get_project_operational_timepoints(expected_carbonaceous_projects))
actual_carb_prj_op_tmp = sorted([
(prj, tmp) for (prj, tmp) in instance.CRBN_PRJ_OPR_TMPS
])
self.assertListEqual(expected_carb_prj_op_tmp, actual_carb_prj_op_tmp)
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: GEN_ALWAYS_ON
expected_always_on_gen_set = sorted(["Nuclear_Flexible"])
actual_always_on_gen_set = sorted([prj for prj in instance.GEN_ALWAYS_ON])
self.assertListEqual(expected_always_on_gen_set, actual_always_on_gen_set)
# Set: GEN_ALWAYS_ON_OPR_TMPS
expected_operational_timpoints_by_project = sorted(
get_project_operational_timepoints(expected_always_on_gen_set)
)
actual_operational_timepoints_by_project = sorted(
[(g, tmp) for (g, tmp) in instance.GEN_ALWAYS_ON_OPR_TMPS]
)
self.assertListEqual(
expected_operational_timpoints_by_project,
actual_operational_timepoints_by_project,
)
# Param: gen_always_on_unit_size_mw
expected_unit_size = {"Nuclear_Flexible": 584}
actual_unit_size = {
prj: instance.gen_always_on_unit_size_mw[prj]
for prj in instance.GEN_ALWAYS_ON
}
self.assertDictEqual(expected_unit_size, actual_unit_size)
# Param: gen_always_on_min_stable_level_fraction
expected_min_stable_fraction = {"Nuclear_Flexible": 0.72}
actual_min_stable_fraction = {
prj: instance.gen_always_on_min_stable_level_fraction[prj]
for prj in instance.GEN_ALWAYS_ON
}
self.assertDictEqual(expected_min_stable_fraction, actual_min_stable_fraction)
# Param: gen_always_on_ramp_up_when_on_rate
expected_ramp_up_when_on_rate = {"Nuclear_Flexible": 0.18}
actual_ramp_down_when_on_rate = {
prj: instance.gen_always_on_ramp_up_when_on_rate[prj]
for prj in instance.GEN_ALWAYS_ON
}
self.assertDictEqual(
expected_ramp_up_when_on_rate, actual_ramp_down_when_on_rate
)
# Param: gen_always_on_ramp_down_when_on_rate
expected_ramp_down_when_on_rate = {"Nuclear_Flexible": 0.18}
actual_ramp_down_when_on_rate = {
prj: instance.gen_always_on_ramp_down_when_on_rate[prj]
for prj in instance.GEN_ALWAYS_ON
}
self.assertDictEqual(
expected_ramp_down_when_on_rate, actual_ramp_down_when_on_rate
)
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: LF_RESERVES_DOWN_PROJECTS
expected_projects = sorted([
"Gas_CCGT",
"Gas_CCGT_New",
"Gas_CCGT_New_Binary",
"Gas_CCGT_z2",
"Battery",
"Battery_Binary",
"Battery_Specified",
"Hydro",
"Hydro_NonCurtailable",
])
actual_projects = sorted(
[prj for prj in instance.LF_RESERVES_DOWN_PROJECTS])
self.assertListEqual(expected_projects, actual_projects)
# Param: lf_reserves_down_zone
expected_reserves_zone = OrderedDict(
sorted({
"Gas_CCGT": "Zone1",
"Gas_CCGT_New": "Zone1",
"Gas_CCGT_New_Binary": "Zone1",
"Gas_CCGT_z2": "Zone2",
"Battery": "Zone1",
"Battery_Binary": "Zone1",
"Battery_Specified": "Zone1",
"Hydro": "Zone1",
"Hydro_NonCurtailable": "Zone1",
}.items()))
actual_reserves_zone = OrderedDict(
sorted({
prj: instance.lf_reserves_down_zone[prj]
for prj in instance.LF_RESERVES_DOWN_PROJECTS
}.items()))
self.assertDictEqual(expected_reserves_zone, actual_reserves_zone)
# Set: LF_RESERVES_DOWN_PRJ_OPR_TMPS
expected_prj_op_tmps = sorted(
get_project_operational_timepoints(expected_projects))
actual_prj_op_tmps = sorted([
(prj, tmp) for (prj, tmp) in instance.LF_RESERVES_DOWN_PRJ_OPR_TMPS
])
self.assertListEqual(expected_prj_op_tmps, actual_prj_op_tmps)
# Param: lf_reserves_down_derate (defaults to 1 if not specified)
expected_derate = OrderedDict(
sorted({
"Battery": 1,
"Battery_Binary": 1,
"Battery_Specified": 0.5,
"Gas_CCGT": 1,
"Gas_CCGT_New": 1,
"Gas_CCGT_New_Binary": 1,
"Gas_CCGT_z2": 1,
"Hydro": 1,
"Hydro_NonCurtailable": 1,
}.items()))
actual_derate = OrderedDict(
sorted({
prj: instance.lf_reserves_down_derate[prj]
for prj in instance.LF_RESERVES_DOWN_PROJECTS
}.items()))
self.assertDictEqual(expected_derate, actual_derate)
# Param: lf_reserves_down_reserve_to_energy_adjustment
# (defaults to 0 if not specified)
expected_adjustment = OrderedDict(
sorted({
"Zone1": 0.1,
"Zone2": 0
}.items()))
actual_adjustment = OrderedDict(
sorted({
z: instance.lf_reserves_down_reserve_to_energy_adjustment[z]
for z in instance.LF_RESERVES_DOWN_ZONES
}.items()))
self.assertDictEqual(expected_adjustment, actual_adjustment)
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)
# Load test data as dataframes
projects_df = pd.read_csv(os.path.join(TEST_DATA_DIRECTORY, "inputs",
"projects.tab"),
sep="\t")
var_om_curve_df = pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs",
"variable_om_curves.tab"),
sep="\t",
)
startup_by_st_df = pd.read_csv(os.path.join(TEST_DATA_DIRECTORY,
"inputs",
"startup_chars.tab"),
sep="\t")
timepoints_df = pd.read_csv(
os.path.join(TEST_DATA_DIRECTORY, "inputs", "timepoints.tab"),
sep="\t",
usecols=["timepoint", "period"],
)
# Set: VAR_OM_COST_SIMPLE_PRJ_OPR_TMPS
expected_var_om_simple_projects = sorted(
projects_df[projects_df["variable_om_cost_per_mwh"] != "."]
["project"].tolist())
expected_var_om_simple_prj_tmps = get_project_operational_timepoints(
expected_var_om_simple_projects)
actual_var_om_simple_prj_tmps = sorted([
(p, tmp) for (p, tmp) in instance.VAR_OM_COST_SIMPLE_PRJ_OPR_TMPS
])
self.assertListEqual(expected_var_om_simple_prj_tmps,
actual_var_om_simple_prj_tmps)
# Set: VAR_OM_COST_CURVE_PRJS_OPR_TMPS
expected_var_om_curve_projects = sorted(
var_om_curve_df["project"].unique().tolist())
expected_var_om_curve_prj_tmps = get_project_operational_timepoints(
expected_var_om_curve_projects)
actual_var_om_curve_prj_tmps = sorted([
(p, tmp) for (p, tmp) in instance.VAR_OM_COST_CURVE_PRJS_OPR_TMPS
])
self.assertListEqual(expected_var_om_curve_prj_tmps,
actual_var_om_curve_prj_tmps)
# Set: VAR_OM_COST_CURVE_PRJS_OPR_TMPS_SGMS
expected_segments_by_prj_period = {
("Disp_Binary_Commit", 2020): [0, 1],
("Disp_Binary_Commit", 2030): [0],
("Disp_Cont_Commit", 2020): [0],
("Disp_Cont_Commit", 2030): [0],
}
expected_var_om_curve_prj_tmp_sgms = list()
for (prj, tmp) in expected_var_om_curve_prj_tmps:
prd = timepoints_df[timepoints_df["timepoint"] ==
tmp].iloc[0]["period"]
segments = expected_segments_by_prj_period[prj, prd]
for sgm in segments:
expected_var_om_curve_prj_tmp_sgms.append((prj, tmp, sgm))
actual_var_om_curve_prj_tmp_sgms = sorted([
(prj, tmp, sgm)
for (prj, tmp,
sgm) in instance.VAR_OM_COST_CURVE_PRJS_OPR_TMPS_SGMS
])
self.assertListEqual(expected_var_om_curve_prj_tmp_sgms,
actual_var_om_curve_prj_tmp_sgms)
# Set: VAR_OM_COST_ALL_PRJS_OPR_TMPS
expected_var_om_all_prj_tmps = sorted(
list(
set(expected_var_om_simple_prj_tmps +
expected_var_om_curve_prj_tmps)))
actual_var_om_all_prj_tmps = sorted([
(p, tmp) for (p, tmp) in instance.VAR_OM_COST_ALL_PRJS_OPR_TMPS
])
self.assertListEqual(expected_var_om_all_prj_tmps,
actual_var_om_all_prj_tmps)
# Set: STARTUP_COST_PRJ_OPR_TMPS
expected_startup_cost_simple_projects = sorted(projects_df[
projects_df["startup_cost_per_mw"] != "."]["project"].tolist())
expected_startup_by_st_projects = sorted(
startup_by_st_df["project"].unique().tolist())
expected_startup_cost_all_projects = sorted(
list(
set(expected_startup_cost_simple_projects +
expected_startup_by_st_projects)))
expected_startup_cost_all_prj_tmps = get_project_operational_timepoints(
expected_startup_cost_all_projects)
actual_startup_cost_all_prj_tmps = sorted([
(p, tmp) for (p, tmp) in instance.STARTUP_COST_PRJ_OPR_TMPS
])
self.assertListEqual(expected_startup_cost_all_prj_tmps,
actual_startup_cost_all_prj_tmps)
# Set: SHUTDOWN_COST_PRJ_OPR_TMPS
expected_shutdown_cost_projects = sorted(projects_df[
projects_df["shutdown_cost_per_mw"] != "."]["project"].tolist())
expected_shutdown_cost_prj_tmps = get_project_operational_timepoints(
expected_shutdown_cost_projects)
actual_shutdown_cost_prj_tmps = sorted([
(p, tmp) for (p, tmp) in instance.SHUTDOWN_COST_PRJ_OPR_TMPS
])
self.assertListEqual(expected_shutdown_cost_prj_tmps,
actual_shutdown_cost_prj_tmps)
# Set: VIOL_ALL_PRJ_OPR_TMPS
expected_ramp_up_viol_projects = sorted(
projects_df[projects_df["ramp_up_violation_penalty"] != "."]
["project"].tolist())
expected_ramp_down_viol_projects = sorted(
projects_df[projects_df["ramp_down_violation_penalty"] != "."]
["project"].tolist())
expected_min_up_time_viol_projects = sorted(
projects_df[projects_df["min_up_time_violation_penalty"] != "."]
["project"].tolist())
expected_min_down_time_viol_projects = sorted(
projects_df[projects_df["min_down_time_violation_penalty"] != "."]
["project"].tolist())
expected_opr_viol_prj_tmps = get_project_operational_timepoints(
expected_ramp_up_viol_projects + expected_ramp_down_viol_projects +
expected_min_up_time_viol_projects +
expected_min_down_time_viol_projects)
actual_opr_viol_prj_tmps = sorted([
(p, tmp) for (p, tmp) in instance.VIOL_ALL_PRJ_OPR_TMPS
])
self.assertListEqual(expected_opr_viol_prj_tmps,
actual_opr_viol_prj_tmps)
# Set: CURTAILMENT_COST_PRJ_OPR_TMPS
expected_curt_cost_projects = sorted(
projects_df[projects_df["curtailment_cost_per_pwh"] != "."]
["project"].tolist())
expected_curt_cost_prj_tmps = get_project_operational_timepoints(
expected_curt_cost_projects)
actual_curt_cost_prj_tmps = sorted([
(p, tmp) for (p, tmp) in instance.CURTAILMENT_COST_PRJ_OPR_TMPS
])
self.assertListEqual(expected_curt_cost_prj_tmps,
actual_curt_cost_prj_tmps)
