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)