def test_get_func_wrong_error(self):
     """Test get_func method with wrong inputs."""
     imp_fun = ImpactFuncSet()
     vulner_1 = ImpactFunc()
     vulner_1.haz_type = 'WS'
     vulner_1.id = 56
     imp_fun.append(vulner_1)
     self.assertEqual([], imp_fun.get_func('TC'))
    def test_get_func_pass(self):
        """Test normal functionality of get_func method."""
        imp_fun = ImpactFuncSet()
        vulner_1 = ImpactFunc()
        vulner_1.haz_type = 'WS'
        vulner_1.id = 56
        imp_fun.append(vulner_1)
        self.assertEqual(1, len(imp_fun.get_func('WS')))
        self.assertEqual(1, len(imp_fun.get_func(fun_id=56)))
        self.assertIs(vulner_1, imp_fun.get_func('WS', 56))

        vulner_2 = ImpactFunc()
        vulner_2.haz_type = 'WS'
        vulner_2.id = 6
        imp_fun.append(vulner_2)
        self.assertEqual(2, len(imp_fun.get_func('WS')))
        self.assertEqual(1, len(imp_fun.get_func(fun_id=6)))
        self.assertIs(vulner_2, imp_fun.get_func('WS', 6))

        vulner_3 = ImpactFunc()
        vulner_3.haz_type = 'TC'
        vulner_3.id = 6
        imp_fun.append(vulner_3)
        self.assertEqual(2, len(imp_fun.get_func(fun_id=6)))
        self.assertEqual(1, len(imp_fun.get_func(fun_id=56)))
        self.assertEqual(2, len(imp_fun.get_func('WS')))
        self.assertEqual(1, len(imp_fun.get_func('TC')))
        self.assertIs(vulner_3, imp_fun.get_func('TC', 6))

        self.assertEqual(2, len(imp_fun.get_func().keys()))
        self.assertEqual(1, len(imp_fun.get_func()['TC'].keys()))
        self.assertEqual(2, len(imp_fun.get_func()['WS'].keys()))
Example #3
0
    def test_filter_exposures_pass(self):
        """Test _filter_exposures method with two values"""
        meas = Measure()
        meas.exp_region_id = [3, 4]
        meas.haz_type = 'TC'

        exp = Exposures()
        exp.read_mat(ENT_TEST_MAT)
        exp.gdf.rename(columns={'if_': 'if_TC', 'centr_': 'centr_TC'}, inplace=True)
        exp.gdf['region_id'] = np.ones(exp.gdf.shape[0])
        exp.gdf.region_id.values[:exp.gdf.shape[0] // 2] = 3
        exp.gdf.region_id[0] = 4
        exp.check()

        imp_set = ImpactFuncSet()
        imp_set.read_mat(ENT_TEST_MAT)

        haz = Hazard('TC')
        haz.read_mat(HAZ_TEST_MAT)
        exp.assign_centroids(haz)

        new_exp = copy.deepcopy(exp)
        new_exp.gdf['value'] *= 3
        new_exp.gdf['if_TC'].values[:20] = 2
        new_exp.gdf['if_TC'].values[20:40] = 3
        new_exp.gdf['if_TC'].values[40:] = 1

        new_ifs = copy.deepcopy(imp_set)
        new_ifs.get_func('TC')[1].intensity += 1
        ref_ifs = copy.deepcopy(new_ifs)

        new_haz = copy.deepcopy(haz)
        new_haz.intensity *= 4

        res_exp, res_ifs, res_haz = meas._filter_exposures(exp, imp_set, haz,
            new_exp.copy(deep=True), new_ifs, new_haz)

        # unchanged meta data
        self.assertEqual(res_exp.ref_year, exp.ref_year)
        self.assertEqual(res_exp.value_unit, exp.value_unit)
        self.assertEqual(res_exp.tag.file_name, exp.tag.file_name)
        self.assertEqual(res_exp.tag.description, exp.tag.description)
        self.assertEqual(res_exp.crs, exp.crs)
        self.assertEqual(res_exp.gdf.crs, exp.gdf.crs)

        # regions (that is just input data, no need for testing, but it makes the changed and unchanged parts obious)
        self.assertTrue(np.array_equal(res_exp.gdf.region_id.values[0], 4))
        self.assertTrue(np.array_equal(res_exp.gdf.region_id.values[1:25], np.ones(24) * 3))
        self.assertTrue(np.array_equal(res_exp.gdf.region_id.values[25:], np.ones(25)))

        # changed exposures
        self.assertTrue(np.array_equal(res_exp.gdf.value.values[:25], new_exp.gdf.value.values[:25]))
        self.assertTrue(np.all(np.not_equal(res_exp.gdf.value.values[:25], exp.gdf.value.values[:25])))
        self.assertTrue(np.all(np.not_equal(res_exp.gdf.if_TC.values[:25], new_exp.gdf.if_TC.values[:25])))
        self.assertTrue(np.array_equal(res_exp.gdf.latitude.values[:25], new_exp.gdf.latitude.values[:25]))
        self.assertTrue(np.array_equal(res_exp.gdf.longitude.values[:25], new_exp.gdf.longitude.values[:25]))

        # unchanged exposures
        self.assertTrue(np.array_equal(res_exp.gdf.value.values[25:], exp.gdf.value.values[25:]))
        self.assertTrue(np.all(np.not_equal(res_exp.gdf.value.values[25:], new_exp.gdf.value.values[25:])))
        self.assertTrue(np.array_equal(res_exp.gdf.if_TC.values[25:], exp.gdf.if_TC.values[25:]))
        self.assertTrue(np.array_equal(res_exp.gdf.latitude.values[25:], exp.gdf.latitude.values[25:]))
        self.assertTrue(np.array_equal(res_exp.gdf.longitude.values[25:], exp.gdf.longitude.values[25:]))

        # unchanged impact functions
        self.assertEqual(list(res_ifs.get_func().keys()), [meas.haz_type])
        self.assertEqual(res_ifs.get_func()[meas.haz_type][1].id, imp_set.get_func()[meas.haz_type][1].id)
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][1].intensity,
                                       imp_set.get_func()[meas.haz_type][1].intensity))
        self.assertEqual(res_ifs.get_func()[meas.haz_type][3].id, imp_set.get_func()[meas.haz_type][3].id)
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][3].intensity,
                                       imp_set.get_func()[meas.haz_type][3].intensity))

        # changed impact functions
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][1 + IF_ID_FACT].intensity,
                        ref_ifs.get_func()[meas.haz_type][1].intensity))
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][1 + IF_ID_FACT].paa,
                        ref_ifs.get_func()[meas.haz_type][1].paa))
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][1 + IF_ID_FACT].mdd,
                        ref_ifs.get_func()[meas.haz_type][1].mdd))
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][3 + IF_ID_FACT].intensity,
                        ref_ifs.get_func()[meas.haz_type][3].intensity))
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][3 + IF_ID_FACT].paa,
                        ref_ifs.get_func()[meas.haz_type][3].paa))
        self.assertTrue(np.array_equal(res_ifs.get_func()[meas.haz_type][3 + IF_ID_FACT].mdd,
                        ref_ifs.get_func()[meas.haz_type][3].mdd))

        # unchanged hazard
        self.assertTrue(np.array_equal(res_haz.intensity[:, :36].toarray(),
                        haz.intensity[:, :36].toarray()))
        self.assertTrue(np.array_equal(res_haz.intensity[:, 37:46].toarray(),
                        haz.intensity[:, 37:46].toarray()))
        self.assertTrue(np.array_equal(res_haz.intensity[:, 47:].toarray(),
                        haz.intensity[:, 47:].toarray()))

        # changed hazard
        self.assertTrue(np.array_equal(res_haz.intensity[[36, 46]].toarray(),
                        new_haz.intensity[[36, 46]].toarray()))
Example #4
0
    def test_write_read_pass(self):
        """Write + read excel file"""

        imp_funcs = ImpactFuncSet()
        imp_funcs.tag.file_name = 'No file name'
        imp_funcs.tag.description = 'test writer'

        imp1 = ImpactFunc()
        imp1.id = 1
        imp1.name = 'code 1'
        imp1.intensity_unit = 'm/s'
        imp1.haz_type = 'TC'
        imp1.intensity = np.arange(100)
        imp1.mdd = np.arange(100) * 0.5
        imp1.paa = np.ones(100)
        imp_funcs.append(imp1)

        imp2 = ImpactFunc()
        imp2.id = 2
        imp2.name = 'code 2'
        imp2.intensity_unit = 'm/s'
        imp2.haz_type = 'TC'
        imp2.intensity = np.arange(102)
        imp2.mdd = np.arange(102) * 0.25
        imp2.paa = np.ones(102)
        imp_funcs.append(imp2)

        imp3 = ImpactFunc()
        imp3.id = 1
        imp3.name = 'code 1'
        imp3.intensity_unit = 'm'
        imp3.haz_type = 'FL'
        imp3.intensity = np.arange(86)
        imp3.mdd = np.arange(86) * 0.15
        imp3.paa = np.ones(86)
        imp_funcs.append(imp3)

        imp4 = ImpactFunc()
        imp4.id = 15
        imp4.name = 'code 15'
        imp4.intensity_unit = 'K'
        imp4.haz_type = 'DR'
        imp4.intensity = np.arange(5)
        imp4.mdd = np.arange(5)
        imp4.paa = np.ones(5)
        imp_funcs.append(imp4)

        file_name = CONFIG.impact_funcs.test_data.dir().joinpath('test_write.xlsx')
        imp_funcs.write_excel(file_name)

        imp_res = ImpactFuncSet()
        imp_res.read_excel(file_name)

        self.assertEqual(imp_res.tag.file_name, str(file_name))
        self.assertEqual(imp_res.tag.description, '')

        # first function
        for fun_haz, fun_dict in imp_res.get_func().items():
            for fun_id, fun in fun_dict.items():
                if fun_haz == 'TC' and fun_id == 1:
                    ref_fun = imp1
                elif fun_haz == 'TC' and fun_id == 2:
                    ref_fun = imp2
                elif fun_haz == 'FL' and fun_id == 1:
                    ref_fun = imp3
                elif fun_haz == 'DR' and fun_id == 15:
                    ref_fun = imp4
                else:
                    self.assertEqual(1, 0)

                self.assertEqual(ref_fun.haz_type, fun.haz_type)
                self.assertEqual(ref_fun.id, fun.id)
                self.assertEqual(ref_fun.name, fun.name)
                self.assertEqual(ref_fun.intensity_unit, fun.intensity_unit)
                self.assertTrue(np.allclose(ref_fun.intensity, fun.intensity))
                self.assertTrue(np.allclose(ref_fun.mdd, fun.mdd))
                self.assertTrue(np.allclose(ref_fun.paa, fun.paa))
Example #5
0
    def test_filter_exposures_pass(self):
        """Test _filter_exposures method with -1"""
        meas = Measure()
        meas.exp_region_id = 3
        meas.haz_type = 'TC'

        exp = Exposures()
        exp.read_mat(ENT_TEST_MAT)
        exp.rename(columns={
            'if_': 'if_TC',
            'centr_': 'centr_TC'
        },
                   inplace=True)
        exp['region_id'] = np.ones(exp.shape[0])
        exp.region_id.values[:exp.shape[0] // 2] = 3

        imp_set = ImpactFuncSet()
        imp_set.read_mat(ENT_TEST_MAT)

        haz = Hazard('TC')
        haz.read_mat(HAZ_TEST_MAT)

        new_exp = copy.deepcopy(exp)
        new_exp['value'] *= 3
        new_exp['if_TC'].values[:20] = 2
        new_exp['if_TC'].values[20:40] = 3
        new_exp['if_TC'].values[40:] = 1

        new_ifs = copy.deepcopy(imp_set)
        new_ifs.get_func('TC')[1].intensity += 1
        ref_ifs = copy.deepcopy(new_ifs)

        new_haz = copy.deepcopy(haz)
        new_haz.intensity *= 4

        res_exp, res_ifs, res_haz = meas._filter_exposures(
            exp, imp_set, haz, new_exp, new_ifs, new_haz)

        # unchanged exposures
        self.assertEqual(res_exp.ref_year, exp.ref_year)
        self.assertEqual(res_exp.value_unit, exp.value_unit)
        self.assertEqual(res_exp.tag.file_name, exp.tag.file_name)
        self.assertEqual(res_exp.tag.description, exp.tag.description)
        self.assertTrue(
            np.array_equal(res_exp.value.values[exp.shape[0] // 2:],
                           new_exp.value.values[:exp.shape[0] // 2]))
        self.assertTrue(
            np.array_equal(res_exp.region_id.values[exp.shape[0] // 2:],
                           np.ones(exp.shape[0] // 2) * 3))
        self.assertTrue(
            np.array_equal(res_exp.if_TC.values[exp.shape[0] // 2:],
                           new_exp.if_TC.values[:exp.shape[0] // 2]))
        self.assertTrue(
            np.array_equal(res_exp.latitude.values[exp.shape[0] // 2:],
                           new_exp.latitude.values[:exp.shape[0] // 2]))
        self.assertTrue(
            np.array_equal(res_exp.longitude.values[exp.shape[0] // 2:],
                           new_exp.longitude.values[:exp.shape[0] // 2]))

        # changed exposures
        self.assertTrue(
            np.array_equal(res_exp.value.values[:exp.shape[0] // 2],
                           exp.value.values[exp.shape[0] // 2:]))
        self.assertTrue(
            np.array_equal(res_exp.region_id.values[:exp.shape[0] // 2],
                           np.ones(exp.shape[0] // 2)))
        self.assertTrue(
            np.array_equal(res_exp.if_TC.values[:exp.shape[0] // 2],
                           exp.if_TC.values[exp.shape[0] // 2:]))
        self.assertTrue(
            np.array_equal(res_exp.latitude.values[:exp.shape[0] // 2],
                           exp.latitude.values[exp.shape[0] // 2:]))
        self.assertTrue(
            np.array_equal(res_exp.longitude.values[:exp.shape[0] // 2],
                           exp.longitude.values[exp.shape[0] // 2:]))

        # unchanged impact functions
        self.assertEqual(list(res_ifs.get_func().keys()), [meas.haz_type])
        self.assertEqual(res_ifs.get_func()[meas.haz_type][1].id,
                         imp_set.get_func()[meas.haz_type][1].id)
        self.assertTrue(
            np.array_equal(res_ifs.get_func()[meas.haz_type][1].intensity,
                           imp_set.get_func()[meas.haz_type][1].intensity))
        self.assertEqual(res_ifs.get_func()[meas.haz_type][3].id,
                         imp_set.get_func()[meas.haz_type][3].id)
        self.assertTrue(
            np.array_equal(res_ifs.get_func()[meas.haz_type][3].intensity,
                           imp_set.get_func()[meas.haz_type][3].intensity))

        # changed impact functions
        self.assertTrue(
            np.array_equal(
                res_ifs.get_func()[meas.haz_type][1 + IF_ID_FACT].intensity,
                ref_ifs.get_func()[meas.haz_type][1].intensity))
        self.assertTrue(
            np.array_equal(
                res_ifs.get_func()[meas.haz_type][1 + IF_ID_FACT].paa,
                ref_ifs.get_func()[meas.haz_type][1].paa))
        self.assertTrue(
            np.array_equal(
                res_ifs.get_func()[meas.haz_type][1 + IF_ID_FACT].mdd,
                ref_ifs.get_func()[meas.haz_type][1].mdd))
        self.assertTrue(
            np.array_equal(
                res_ifs.get_func()[meas.haz_type][3 + IF_ID_FACT].intensity,
                ref_ifs.get_func()[meas.haz_type][3].intensity))
        self.assertTrue(
            np.array_equal(
                res_ifs.get_func()[meas.haz_type][3 + IF_ID_FACT].paa,
                ref_ifs.get_func()[meas.haz_type][3].paa))
        self.assertTrue(
            np.array_equal(
                res_ifs.get_func()[meas.haz_type][3 + IF_ID_FACT].mdd,
                ref_ifs.get_func()[meas.haz_type][3].mdd))

        # unchanged hazard
        self.assertTrue(
            np.array_equal(res_haz.intensity[:, :36].todense(),
                           haz.intensity[:, :36].todense()))
        self.assertTrue(
            np.array_equal(res_haz.intensity[:, 37:46].todense(),
                           haz.intensity[:, 37:46].todense()))
        self.assertTrue(
            np.array_equal(res_haz.intensity[:, 47:].todense(),
                           haz.intensity[:, 47:].todense()))

        # changed hazard
        self.assertTrue(
            np.array_equal(res_haz.intensity[[36, 46]].todense(),
                           new_haz.intensity[[36, 46]].todense()))