Пример #1
0
    def test_switch_type(self, test_net, diag_params, diag_errors, report_methods):
        net = copy.deepcopy(test_net)
        check_function = 'invalid_values'
        diag_params = copy.deepcopy(diag_params)
        report_methods = copy.deepcopy(report_methods)
        net.switch.loc[0, 'et'] = 'bus'
        net.switch.loc[1, 'et'] = 1
        net.switch.loc[2, 'et'] = None
        net.switch.loc[3, 'et'] = True
        net.switch.loc[4, 'et'] = 't'

        check_result = pp.invalid_values(net)
        if check_result:
            diag_results = {check_function: check_result}
        else:
            diag_results = {}
        assert diag_results[check_function] == \
        {'switch': [(0, 'et', 'bus', 'switch_type'),
                    (1, 'et', 1, 'switch_type'),
                    (2, 'et', 'None', 'switch_type'),
                    (3, 'et', True, 'switch_type')]}

        for bool_value in [True, False]:
            diag_report = DiagnosticReports(net, diag_results, diag_errors, diag_params, compact_report=bool_value)
            report_check = None
            try:
                eval(report_methods[check_function])
                report_check = True
            except:
                report_check = False
            assert report_check
Пример #2
0
    def test_greater_zero(self, test_net):
        net = copy.deepcopy(test_net)
        net.bus.loc[42, 'vn_kv'] = '-1'
        net.line.loc[7, 'length_km'] = -1
        net.line.loc[8, 'imax_ka'] = 0
        net.trafo.loc[0, 'vsc_percent'] = 0.0
        net.trafo.loc[0, 'sn_kva'] = None
        net.trafo.loc[0, 'vn_hv_kv'] = -1.5
        net.trafo.loc[0, 'vn_lv_kv'] = False
        net.trafo3w.loc[0, 'vsc_hv_percent'] = 2.3
        net.trafo3w.loc[0, 'vsc_mv_percent'] = np.nan
        net.trafo3w.loc[0, 'vsc_lv_percent'] = 0.0
        net.trafo3w.loc[0, 'sn_hv_kva'] = 11
        net.trafo3w.loc[0, 'sn_mv_kva'] = 'a'
        net.trafo3w.loc[0, 'vn_hv_kv'] = -1.5
        net.trafo3w.loc[0, 'vn_mv_kv'] = -1.5
        net.trafo3w.loc[0, 'vn_lv_kv'] = False
        net.ext_grid.loc[0, 'vm_pu'] = True

        assert pp.invalid_values(net) == \
        {'bus': [(42, 'vn_kv', '-1', '>0')],
         'ext_grid': [(0, 'vm_pu', True, '>0')],
         'line': [(7, 'length_km', -1.0, '>0'), (8, 'imax_ka', 0.0, '>0')],
         'trafo': [(0, 'sn_kva', 'nan', '>0'), (0, 'vn_hv_kv', -1.5, '>0'),
                   (0, 'vn_lv_kv', False, '>0'), (0, 'vsc_percent', 0.0, '>0')],
         'trafo3w': [(0, 'sn_mv_kva', 'a', '>0'), (0, 'vn_hv_kv', -1.5, '>0'),
                     (0, 'vn_mv_kv', -1.5, '>0'), (0, 'vn_lv_kv', False, '>0'),
                     (0, 'vsc_mv_percent', 'nan', '>0'), (0, 'vsc_lv_percent', 0.0, '>0')]}
Пример #3
0
    def test_number(self, test_net, diag_params, diag_errors, report_methods):
        net = copy.deepcopy(test_net)
        check_function = 'invalid_values'
        diag_params = copy.deepcopy(diag_params)
        report_methods = copy.deepcopy(report_methods)
        net.load.loc[0, 'p_mw'] = '1000'
        net.load.loc[1, 'q_mvar'] = None
        net.gen.loc[0, 'p_mw'] = False
        net.sgen.loc[0, 'p_mw'] = -1.5
        net.sgen.loc[1, 'q_mvar'] = np.nan
        net.ext_grid.loc[0, 'va_degree'] = 13.55

        check_result = pp.invalid_values(net)
        if check_result:
            diag_results = {check_function: check_result}
        else:
            diag_results = {}
        assert diag_results[check_function] == \
        {'gen': [(0, 'p_mw', False, 'number')],
         'load': [(0, 'p_mw', '1000', 'number'), (1, 'q_mvar', 'nan', 'number')],
         'sgen': [(1, 'q_mvar', 'nan', 'number')]}

        for bool_value in [True, False]:
            diag_report = DiagnosticReports(net, diag_results, diag_errors, diag_params, compact_report=bool_value)
            report_check = None
            try:
                eval(report_methods[check_function])
                report_check = True
            except:
                report_check = False
            assert report_check
Пример #4
0
    def test_between_zero_and_one(self, test_net, diag_params, diag_errors,
                                  report_methods):
        net = copy.deepcopy(test_net)
        check_function = 'invalid_values'
        diag_params = copy.deepcopy(diag_params)
        report_methods = copy.deepcopy(report_methods)
        net.line.loc[0, 'df'] = 1.5

        check_result = pp.invalid_values(net)
        if check_result:
            diag_results = {check_function: check_result}
        else:
            diag_results = {}
        assert diag_results[check_function] == \
        {'line': [(0, 'df', 1.5, '0<x<=1')]}

        for bool_value in [True, False]:
            diag_report = DiagnosticReports(net,
                                            diag_results,
                                            diag_errors,
                                            diag_params,
                                            compact_report=bool_value)
            report_check = None
            try:
                eval(report_methods[check_function])
                report_check = True
            except:
                report_check = False
            assert report_check
Пример #5
0
    def test_boolean(self, test_net):
        net = copy.deepcopy(test_net)
        net.sgen.loc[0, 'in_service'] = 0
        net.sgen.loc[1, 'in_service'] = 0.0
        net.sgen.loc[2, 'in_service'] = '0'
        net.sgen.loc[3, 'in_service'] = '0.0'
        net.sgen.loc[4, 'in_service'] = 1
        net.gen.loc[0, 'in_service'] = '1'
        net.load.loc[0, 'in_service'] = 10
        net.line.loc[0, 'in_service'] = -1
        net.bus.loc[0, 'in_service'] = 'no'
        net.trafo.loc[0, 'in_service'] = 'True'
        net.trafo3w.loc[0, 'in_service'] = None
        net.switch.loc[0, 'closed'] = 0
        net.switch.loc[1, 'closed'] = 'False'
        net.switch.loc[2, 'closed'] = False
        net.switch.loc[3, 'closed'] = 'False'
        net.switch.loc[4, 'closed'] = None
        net.switch.loc[5, 'closed'] = 10

        assert pp.invalid_values(net) ==  \
        {'bus': [(0, 'in_service', 'no', 'boolean')],
         'gen': [(0, 'in_service', '1', 'boolean')],
         'sgen': [(2, 'in_service', '0', 'boolean'), (3, 'in_service', '0.0', 'boolean')],
         'switch': [(1, 'closed', 'False', 'boolean'), (3, 'closed', 'False', 'boolean'),
                    (4, 'closed', None, 'boolean'), (5, 'closed', 10, 'boolean')],
         'trafo': [(0, 'in_service', 'True', 'boolean')],
         'trafo3w': [(0, 'in_service', 'nan', 'boolean')]}
Пример #6
0
    def test_pos_int(self, test_net):
        net = copy.deepcopy(test_net)
        net.line.loc[7, 'from_bus'] = 1
        net.line.loc[8, 'to_bus'] = '2'
        net.trafo.loc[0, 'hv_bus'] = False
        net.trafo.loc[0, 'lv_bus'] = None
        net.trafo3w.loc[0, 'hv_bus'] = False
        net.trafo3w.loc[0, 'mv_bus'] = 0.5
        net.trafo3w.loc[0, 'lv_bus'] = 2
        net.load.loc[0, 'bus'] = True
        net.sgen.loc[0, 'bus'] = 1.5
        net.gen.loc[0, 'bus'] = np.nan
        net.ext_grid.loc[0, 'bus'] = -2.5
        net.switch.loc[0, 'bus'] = None
        net.switch.loc[0, 'element'] = -1.5

        assert pp.invalid_values(net) ==   \
        {'ext_grid': [(0, 'bus', -2.5, 'positive_integer')],
         'gen': [(0, 'bus', 'nan', 'positive_integer')],
         'line': [(8, 'to_bus', '2', 'positive_integer')],
         'load': [(0, 'bus', True, 'positive_integer')],
         'sgen': [(0, 'bus', 1.5, 'positive_integer')],
         'switch': [(0, 'bus', 'nan', 'positive_integer'),
                    (0, 'element', -1.5, 'positive_integer')],
         'trafo': [(0, 'hv_bus', False, 'positive_integer'),
                   (0, 'lv_bus', 'nan', 'positive_integer')],
         'trafo3w': [(0, 'hv_bus', False, 'positive_integer'),
                     (0, 'mv_bus', 0.5, 'positive_integer')]}
Пример #7
0
    def test_boolean(self, test_net, diag_params, report_methods):
        net = copy.deepcopy(test_net)
        check_function = 'invalid_values'
        diag_params = copy.deepcopy(diag_params)
        report_methods = copy.deepcopy(report_methods)
        net.sgen.loc[0, 'in_service'] = 0
        net.sgen.loc[1, 'in_service'] = 0.0
        net.sgen.loc[2, 'in_service'] = '0'
        net.sgen.loc[3, 'in_service'] = '0.0'
        net.sgen.loc[4, 'in_service'] = 1
        net.gen.loc[0, 'in_service'] = '1'
        net.load.loc[0, 'in_service'] = '10'
        net.line.loc[0, 'in_service'] = '-1'
        net.bus.loc[0, 'in_service'] = 'no'
        net.trafo.loc[0, 'in_service'] = 'True'
        net.trafo3w.loc[0, 'in_service'] = None
        net.switch.loc[0, 'closed'] = 0
        net.switch.loc[1, 'closed'] = 'False'
        net.switch.loc[2, 'closed'] = False
        net.switch.loc[3, 'closed'] = 'False'
        net.switch.loc[4, 'closed'] = None
        net.switch.loc[5, 'closed'] = '10'

        check_result = pp.invalid_values(net)
        if check_result:
            diag_results = {check_function: check_result}
        else:
            diag_results = {}
        assert diag_results[check_function] == \
        {'bus': [(0, 'in_service', 'no', 'boolean')],
         'gen': [(0, 'in_service', '1', 'boolean')],
         'line': [(0, 'in_service', '-1', 'boolean')],
         'load': [(0, 'in_service', '10', 'boolean')],
         'sgen': [(2, 'in_service', '0', 'boolean'),
                  (3, 'in_service', '0.0', 'boolean')],
         'switch': [(1, 'closed', 'False', 'boolean'),
                    (3, 'closed', 'False', 'boolean'),
                    (4, 'closed', 'None', 'boolean'),
                    (5, 'closed', '10', 'boolean')],
         'trafo': [(0, 'in_service', 'True', 'boolean')],
         'trafo3w': [(0, 'in_service', 'nan', 'boolean')]}

        for bool_value in [True, False]:
            diag_report = DiagnosticReports(net,
                                            diag_results,
                                            diag_params,
                                            compact_report=bool_value)
            report_check = None
            try:
                eval(report_methods[check_function])
                report_check = True
            except:
                report_check = False
            assert report_check
Пример #8
0
    def test_switch_type(self, test_net):
        net = copy.deepcopy(test_net)
        net.switch.loc[0, 'et'] = 'bus'
        net.switch.loc[1, 'et'] = 1
        net.switch.loc[2, 'et'] = None
        net.switch.loc[3, 'et'] = True
        net.switch.loc[4, 'et'] = 't'

        assert pp.invalid_values(net) ==  \
        {'switch': [(0, 'et', 'bus', 'switch_type'),
                    (1, 'et', 1, 'switch_type'),
                    (2, 'et', None, 'switch_type'),
                    (3, 'et', True, 'switch_type')]}
Пример #9
0
    def test_number(self, test_net):
        net = copy.deepcopy(test_net)
        net.load.loc[0, 'p_kw'] = '1000'
        net.load.loc[1, 'q_kvar'] = None
        net.gen.loc[0, 'p_kw'] = False
        net.sgen.loc[0, 'p_kw'] = -1.5
        net.sgen.loc[1, 'q_kvar'] = np.nan
        net.ext_grid.loc[0, 'va_degree'] = 13.55

        assert pp.invalid_values(net) ==  \
        {'gen': [(0, 'p_kw', False, 'number')],
         'load': [(0, 'p_kw', '1000', 'number'), (1, 'q_kvar', 'nan', 'number')],
         'sgen': [(1, 'q_kvar', 'nan', 'number')]}
Пример #10
0
    def test_greater_equal_zero(self, test_net, diag_params, diag_errors,
                                report_methods):
        net = copy.deepcopy(test_net)
        check_function = 'invalid_values'
        net.line.loc[7, 'r_ohm_per_km'] = -1
        net.line.loc[8, 'x_ohm_per_km'] = None
        net.line.loc[8, 'c_nf_per_km'] = '0'
        net.trafo.loc[0, 'vkr_percent'] = '-1'
        net.trafo.loc[0, 'pfe_kw'] = -1.5
        net.trafo.loc[0, 'i0_percent'] = -0.001
        net.trafo3w.loc[0, 'vkr_hv_percent'] = True
        net.trafo3w.loc[0, 'vkr_mv_percent'] = False
        net.trafo3w.loc[0, 'vkr_lv_percent'] = 1
        net.trafo3w.loc[0, 'pfe_kw'] = '2'
        net.trafo3w.loc[0, 'i0_percent'] = 10
        net.load.loc[0, 'scaling'] = -0.1
        net.load.loc[1, 'scaling'] = 0
        net.load.loc[2, 'scaling'] = 1
        net.load.loc[3, 'scaling'] = '1'
        net.gen.loc[0, 'scaling'] = None
        net.sgen.loc[0, 'scaling'] = False

        check_result = pp.invalid_values(net)
        if check_result:
            diag_results = {check_function: check_result}
        else:
            diag_results = {}
        assert diag_results[check_function] == \
        {'line': [(7, 'r_ohm_per_km', -1.0, '>=0'), (8, 'x_ohm_per_km', 'nan', '>=0'),
                  (8, 'c_nf_per_km', '0', '>=0')],
         'trafo': [(0, 'vkr_percent', '-1', '>=0'), (0, 'pfe_kw', -1.5, '>=0'),
                   (0, 'i0_percent', -0.001, '>=0')],
         'trafo3w': [(0, 'vkr_hv_percent', True, '>=0'), (0, 'vkr_mv_percent', False, '>=0'),
                     (0, 'pfe_kw', '2', '>=0')],
         'gen': [(0, 'scaling', 'nan', '>=0')],
         'load': [(0, 'scaling', -0.1, '>=0'), (3, 'scaling', '1', '>=0')],
         'sgen': [(0, 'scaling', False, '>=0')]}

        for bool_value in [True, False]:
            diag_report = DiagnosticReports(net,
                                            diag_results,
                                            diag_errors,
                                            diag_params,
                                            compact_report=bool_value)
            report_check = None
            try:
                eval(report_methods[check_function])
                report_check = True
            except:
                report_check = False
            assert report_check
Пример #11
0
    def test_greater_zero(self, test_net, diag_params, diag_errors,
                          report_methods):
        net = copy.deepcopy(test_net)
        check_function = 'invalid_values'
        net.bus.loc[42, 'vn_kv'] = '-1'
        net.line.loc[7, 'length_km'] = -1
        net.line.loc[8, 'max_i_ka'] = 0
        net.trafo.loc[0, 'vk_percent'] = 0.0
        net.trafo.loc[0, 'sn_mva'] = None
        net.trafo.loc[0, 'vn_hv_kv'] = -1.5
        net.trafo.loc[0, 'vn_lv_kv'] = False
        net.trafo3w.loc[0, 'vk_hv_percent'] = 2.3
        net.trafo3w.loc[0, 'vk_mv_percent'] = np.nan
        net.trafo3w.loc[0, 'vk_lv_percent'] = 0.0
        net.trafo3w.loc[0, 'sn_hv_mva'] = 11
        net.trafo3w.loc[0, 'sn_mv_mva'] = 'a'
        net.trafo3w.loc[0, 'vn_hv_kv'] = -1.5
        net.trafo3w.loc[0, 'vn_mv_kv'] = -1.5
        net.trafo3w.loc[0, 'vn_lv_kv'] = False
        net.ext_grid.loc[0, 'vm_pu'] = True

        check_result = pp.invalid_values(net)
        if check_result:
            diag_results = {check_function: check_result}
        else:
            diag_results = {}

        assert diag_results[check_function] == \
        {'bus': [(42, 'vn_kv', '-1', '>0')],
         'ext_grid': [(0, 'vm_pu', True, '>0')],
         'line': [(7, 'length_km', -1.0, '>0'), (8, 'max_i_ka', 0.0, '>0')],
         'trafo': [(0, 'sn_mva', 'nan', '>0'), (0, 'vn_hv_kv', -1.5, '>0'),
                   (0, 'vn_lv_kv', False, '>0'), (0, 'vk_percent', 0.0, '>0')],
         'trafo3w': [(0, 'sn_mv_mva', 'a', '>0'), (0, 'vn_hv_kv', -1.5, '>0'),
                     (0, 'vn_mv_kv', -1.5, '>0'), (0, 'vn_lv_kv', False, '>0'),
                     (0, 'vk_mv_percent', 'nan', '>0'), (0, 'vk_lv_percent', 0.0, '>0')]}

        for bool_value in [True, False]:
            diag_report = DiagnosticReports(net,
                                            diag_results,
                                            diag_errors,
                                            diag_params,
                                            compact_report=bool_value)
            report_check = None
            try:
                eval(report_methods[check_function])
                report_check = True
            except:
                report_check = False
            assert report_check
Пример #12
0
    def test_pos_int(self, test_net, diag_params, diag_errors, report_methods):
        net = copy.deepcopy(test_net)
        check_function = 'invalid_values'
        diag_params = copy.deepcopy(diag_params)
        report_methods = copy.deepcopy(report_methods)
        net.line.loc[7, 'from_bus'] = 1
        net.line.loc[8, 'to_bus'] = '2'
        net.trafo.loc[0, 'hv_bus'] = False
        net.trafo.loc[0, 'lv_bus'] = None
        net.trafo3w.loc[0, 'hv_bus'] = False
        net.trafo3w.loc[0, 'mv_bus'] = 0.5
        net.trafo3w.loc[0, 'lv_bus'] = 2
        net.load.loc[0, 'bus'] = True
        net.sgen.loc[0, 'bus'] = 1.5
        net.gen.loc[0, 'bus'] = np.nan
        net.ext_grid.loc[0, 'bus'] = -2.5
        net.switch.loc[0, 'bus'] = None
        net.switch.loc[0, 'element'] = -1.5

        check_result = pp.invalid_values(net)
        if check_result:
            diag_results = {check_function: check_result}
        else:
            diag_results = {}
        assert diag_results[check_function] == \
        {'ext_grid': [(0, 'bus', -2.5, 'positive_integer')],
         'gen': [(0, 'bus', 'nan', 'positive_integer')],
         'line': [(8, 'to_bus', '2', 'positive_integer')],
         'load': [(0, 'bus', True, 'positive_integer')],
         'sgen': [(0, 'bus', 1.5, 'positive_integer')],
         'switch': [(0, 'bus', 'nan', 'positive_integer'),
                    (0, 'element', -1.5, 'positive_integer')],
         'trafo': [(0, 'hv_bus', False, 'positive_integer'),
                   (0, 'lv_bus', 'nan', 'positive_integer')],
         'trafo3w': [(0, 'hv_bus', False, 'positive_integer'),
                     (0, 'mv_bus', 0.5, 'positive_integer')]}

        for bool_value in [True, False]:
            diag_report = DiagnosticReports(net,
                                            diag_results,
                                            diag_errors,
                                            diag_params,
                                            compact_report=bool_value)
            report_check = None
            try:
                eval(report_methods[check_function])
                report_check = True
            except:
                report_check = False
            assert report_check
Пример #13
0
    def test_between_zero_and_one(self, test_net):
        net = copy.deepcopy(test_net)
        net.line.loc[0, 'df'] = 1.5
        net.load.loc[0, 'scaling'] = -0.1
        net.load.loc[1, 'scaling'] = 0
        net.load.loc[2, 'scaling'] = 1
        net.load.loc[3, 'scaling'] = '1'
        net.gen.loc[0, 'scaling'] = None
        net.sgen.loc[0, 'scaling'] = False

        assert pp.invalid_values(net) ==  \
        {'gen': [(0, 'scaling', 'nan', '0to1')],
         'line': [(0, 'df', 1.5, '0to1')],
         'load': [(0, 'scaling', -0.1, '0to1'), (3, 'scaling', '1', '0to1')],
         'sgen': [(0, 'scaling', False, '0to1')]}
Пример #14
0
    def test_greater_equal_zero(self, test_net):
        net = copy.deepcopy(test_net)
        net.line.loc[7, 'r_ohm_per_km'] = -1
        net.line.loc[8, 'x_ohm_per_km'] = None
        net.line.loc[8, 'c_nf_per_km'] = '0'
        net.trafo.loc[0, 'vscr_percent'] = '-1'
        net.trafo.loc[0, 'pfe_kw'] = -1.5
        net.trafo.loc[0, 'i0_percent'] = -0.001
        net.trafo3w.loc[0, 'vscr_hv_percent'] = True
        net.trafo3w.loc[0, 'vscr_mv_percent'] = False
        net.trafo3w.loc[0, 'vscr_lv_percent'] = 1
        net.trafo3w.loc[0, 'pfe_kw'] = '2'
        net.trafo3w.loc[0, 'i0_percent'] = 10

        assert pp.invalid_values(net) ==  \
        {'line': [(7, 'r_ohm_per_km', -1.0, '>=0'), (8, 'x_ohm_per_km', 'nan', '>=0'),
                  (8, 'c_nf_per_km', '0', '>=0')],
         'trafo': [(0, 'vscr_percent', '-1', '>=0'), (0, 'pfe_kw', -1.5, '>=0'),
                   (0, 'i0_percent', -0.001, '>=0')],
         'trafo3w': [(0, 'vscr_hv_percent', True, '>=0'), (0, 'vscr_mv_percent', False, '>=0'),
                     (0, 'pfe_kw', '2', '>=0')]}