Esempio n. 1
0
    def test_calc_imp_mat_pass(self):
        """Test save imp_mat"""
        # Read default entity values
        ent = Entity()
        ent.read_excel(ENT_DEMO_TODAY)
        ent.check()

        # Read default hazard file
        hazard = Hazard('TC')
        hazard.read_mat(HAZ_TEST_MAT)
        # Create impact object
        impact = Impact()

        # Assign centroids to exposures
        ent.exposures.assign_centroids(hazard)

        # Compute the impact over the whole exposures
        impact.calc(ent.exposures, ent.impact_funcs, hazard, save_mat=True)
        self.assertTrue(isinstance(impact.imp_mat, sparse.csr_matrix))
        self.assertEqual(impact.imp_mat.shape,
                         (hazard.event_id.size, ent.exposures.value.size))
        self.assertTrue(
            np.allclose(
                np.sum(impact.imp_mat, axis=1).reshape(-1), impact.at_event))
        self.assertTrue(
            np.allclose(
                np.array(
                    np.sum(np.multiply(impact.imp_mat.toarray(),
                                       impact.frequency.reshape(-1, 1)),
                           axis=0)).reshape(-1), impact.eai_exp))
Esempio n. 2
0
 def test_impact_year_set_empty(self):
     """Test result for empty impact"""
     imp = Impact()
     iys_all = imp.calc_impact_year_set()
     iys = imp.calc_impact_year_set(all_years=False)
     self.assertEqual(len(iys), 0)
     self.assertEqual(len(iys_all), 0)
Esempio n. 3
0
    def test_calc_imp_mat_pass(self):
        """Test save imp_mat"""
        # Read default entity values
        ent = Entity()
        ent.read_excel(ENT_DEMO_TODAY)
        ent.check()

        # Read default hazard file
        hazard = Hazard('TC')
        hazard.read_mat(HAZ_TEST_MAT)
        # Create impact object
        impact = Impact()

        # Assign centroids to exposures
        ent.exposures.assign_centroids(hazard)

        # Compute the impact over the whole exposures
        impact.calc(ent.exposures, ent.impact_funcs, hazard, save_mat=True)
        self.assertIsInstance(impact.imp_mat, sparse.csr_matrix)
        self.assertEqual(impact.imp_mat.shape, (hazard.event_id.size,
                                                ent.exposures.gdf.value.size))
        np.testing.assert_array_almost_equal_nulp(
            np.array(impact.imp_mat.sum(axis=1)).ravel(), impact.at_event, nulp=5)
        np.testing.assert_array_almost_equal_nulp(
            np.sum(impact.imp_mat.toarray() * impact.frequency[:, None], axis=0).reshape(-1),
            impact.eai_exp)
Esempio n. 4
0
    def test_write_read_excel_pass(self):
        """Test write and read in excel"""
        ent = Entity()
        ent.read_excel(ENT_DEMO_TODAY)
        ent.check()

        hazard = Hazard('TC')
        hazard.read_mat(HAZ_TEST_MAT)
        imp_write = Impact()
        ent.exposures.assign_centroids(hazard)
        imp_write.calc(ent.exposures, ent.impact_funcs, hazard)
        file_name = os.path.join(DATA_FOLDER, 'test.xlsx')
        imp_write.write_excel(file_name)

        imp_read = Impact()
        imp_read.read_excel(file_name)

        self.assertTrue(np.array_equal(imp_write.event_id, imp_read.event_id))
        self.assertTrue(np.array_equal(imp_write.date, imp_read.date))
        self.assertTrue(np.array_equal(imp_write.coord_exp,
                                       imp_read.coord_exp))
        self.assertTrue(np.allclose(imp_write.eai_exp, imp_read.eai_exp))
        self.assertTrue(np.allclose(imp_write.at_event, imp_read.at_event))
        self.assertTrue(np.array_equal(imp_write.frequency,
                                       imp_read.frequency))
        self.assertEqual(imp_write.tot_value, imp_read.tot_value)
        self.assertEqual(imp_write.aai_agg, imp_read.aai_agg)
        self.assertEqual(imp_write.unit, imp_read.unit)
        self.assertEqual(
            0,
            len([
                i for i, j in zip(imp_write.event_name, imp_read.event_name)
                if i != j
            ]))
        self.assertIsInstance(imp_read.crs, dict)
Esempio n. 5
0
    def test_impact_pnt_agg(self):
        """Test impact agreggation method"""
        gdf_mix = GDF_LINE.append(GDF_POLY).append(GDF_POINT).reset_index(
            drop=True)
        exp_mix = Exposures(gdf_mix)

        exp_pnt = u_lp.exp_geom_to_pnt(exp_mix,
                                       res=1,
                                       to_meters=False,
                                       disagg_met=u_lp.DisaggMethod.DIV,
                                       disagg_val=None)
        imp_pnt = Impact()
        imp_pnt.calc(exp_pnt, IMPF_SET, HAZ, save_mat=True)
        imp_agg = u_lp.impact_pnt_agg(imp_pnt, exp_pnt.gdf, u_lp.AggMethod.SUM)
        aai_agg = 1282901.377219451
        eai_exp = np.array([
            1.73069928e-04, 8.80741357e-04, 4.32240819e-03, 8.62816073e-03,
            2.21441154e-02, 1.09329988e-02, 8.58546479e-02, 4.62370081e-02,
            8.99584440e-02, 1.27160538e-02, 8.60317575e-02, 2.02440009e-01,
            2.32808488e-02, 2.86159458e-02, 4.26205598e-03, 2.40051484e-01,
            5.29133033e-03, 2.72705887e-03, 8.87954091e-03, 2.95633263e-02,
            6.33106879e-01, 1.33011693e-03, 1.11120718e-01, 7.72573773e-02,
            6.12233710e-03, 1.61239410e-02, 1.01492204e-01, 7.45522678e-02,
            1.41155415e-01, 1.53820450e-01, 2.27951125e-02, 2.23629697e-02,
            8.59651753e-03, 5.98415680e-03, 1.24717770e-02, 1.24717770e-02,
            1.48060577e-05, 1.48060577e-05, 5.18270742e-03, 5.18270742e-03,
            8.36178802e+03, 7.30704698e+03, 1.20628926e+04, 3.54061498e+04,
            1.23524320e+04, 7.78074661e+04, 1.28292995e+05, 2.31231953e+05,
            1.31911226e+05, 5.37897306e+05, 8.37016948e+04, 1.65661030e+04
        ])
        check_impact(self, imp_agg, HAZ, exp_mix, aai_agg, eai_exp)
Esempio n. 6
0
    def _cutoff_hazard_damage(self, exposures, if_set, hazard):
        """Cutoff of hazard events which generate damage with a frequency higher
        than hazard_freq_cutoff.

        Parameters:
            exposures (Exposures): exposures instance
            imp_set (ImpactFuncSet): impact functions instance
            hazard (Hazard): hazard instance

        Returns:
            ImpactFuncSet
        """
        if self.hazard_freq_cutoff == 0:
            return hazard

        LOGGER.debug('Cutting events whose damage have a frequency > %s.',
                     self.hazard_freq_cutoff)
        from climada.engine.impact import Impact
        imp = Impact()
        exp_imp = exposures
        if self.exp_region_id != 0:
            # compute impact only in selected region
            exp_imp = exposures[exposures.region_id == self.exp_region_id]
            exp_imp = Exposures(exp_imp)
        imp.calc(exp_imp, if_set, hazard)

        new_haz = copy.deepcopy(hazard)
        sort_idxs = np.argsort(imp.at_event)[::-1]
        exceed_freq = np.cumsum(imp.frequency[sort_idxs])
        cutoff = exceed_freq > self.hazard_freq_cutoff
        sel_haz = sort_idxs[cutoff]
        new_haz_inten = new_haz.intensity.tolil()
        new_haz_inten[sel_haz, :] = np.zeros((sel_haz.size, new_haz.intensity.shape[1]))
        new_haz.intensity = new_haz_inten.tocsr()
        return new_haz
Esempio n. 7
0
    def test_calc_geom_impact_points(self):
        """ test calc_geom_impact() with points"""
        imp1 = u_lp.calc_geom_impact(EXP_POINT,
                                     IMPF_SET,
                                     HAZ,
                                     res=0.05,
                                     to_meters=False,
                                     disagg_met=u_lp.DisaggMethod.DIV,
                                     disagg_val=None,
                                     agg_met=u_lp.AggMethod.SUM)
        aai_agg1 = 0.0470814

        imp11 = Impact()
        exp = EXP_POINT.copy()
        exp.set_lat_lon()
        imp11.calc(exp, IMPF_SET, HAZ)
        check_impact(self, imp1, HAZ, EXP_POINT, aai_agg1, imp11.eai_exp)

        imp2 = u_lp.calc_geom_impact(EXP_POINT,
                                     IMPF_SET,
                                     HAZ,
                                     res=500,
                                     to_meters=True,
                                     disagg_met=u_lp.DisaggMethod.FIX,
                                     disagg_val=1.0,
                                     agg_met=u_lp.AggMethod.SUM)

        exp.gdf['value'] = 1.0
        imp22 = Impact()
        imp22.calc(exp, IMPF_SET, HAZ)
        aai_agg2 = 6.5454249333e-06
        check_impact(self, imp2, HAZ, EXP_POINT, aai_agg2, imp22.eai_exp)
Esempio n. 8
0
    def _calc_impact(self, new_exp, new_ifs, new_haz):
        """Compute impact and risk transfer of measure implemented over inputs.

        Parameters:
            new_exp (Exposures): exposures once measure applied
            new_ifs (ImpactFuncSet): impact functions once measure applied
            new_haz (Hazard): hazard once measure applied

        Returns:
            Impact, Impact
        """
        from climada.engine.impact import Impact
        imp = Impact()
        imp.calc(new_exp, new_ifs, new_haz)
        return imp.calc_risk_transfer(self.risk_transf_attach, self.risk_transf_cover)
Esempio n. 9
0
    def test_ref_value_pass(self):
        """Test result against reference value"""
        # Read default entity values
        ent = Entity()
        ent.read_excel(ENT_DEMO_TODAY)
        ent.check()

        # Read default hazard file
        hazard = Hazard('TC')
        hazard.read_mat(HAZ_TEST_MAT)
        # Create impact object
        impact = Impact()

        # Assign centroids to exposures
        ent.exposures.assign_centroids(hazard)

        # Compute the impact over the whole exposures
        impact.calc(ent.exposures, ent.impact_funcs, hazard)

        # Check result
        num_events = len(hazard.event_id)
        num_exp = ent.exposures.shape[0]
        # Check relative errors as well when absolute value gt 1.0e-7
        # impact.at_event == EDS.damage in MATLAB
        self.assertEqual(num_events, len(impact.at_event))
        self.assertEqual(0, impact.at_event[0])
        self.assertEqual(0, impact.at_event[int(num_events / 2)])
        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
        self.assertEqual(7.076504723057620e+10, impact.at_event[12147])
        self.assertEqual(0, impact.at_event[num_events - 1])
        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
        self.assertEqual(num_exp, len(impact.eai_exp))
        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
        self.assertAlmostEqual(1.373490457046383e+08,
                               impact.eai_exp[int(num_exp / 2)], 6)
        self.assertTrue(
            np.isclose(1.373490457046383e+08,
                       impact.eai_exp[int(num_exp / 2)]))
        self.assertAlmostEqual(1.066837260150042e+08,
                               impact.eai_exp[num_exp - 1], 6)
        self.assertTrue(
            np.isclose(1.066837260150042e+08,
                       impact.eai_exp[int(num_exp - 1)]))
        # impact.tot_value == EDS.Value in MATLAB
        # impact.aai_agg == EDS.ED in MATLAB
        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
        self.assertTrue(np.isclose(6.512201157564421e+09, impact.aai_agg))
Esempio n. 10
0
    def _cutoff_hazard_damage(self, exposures, impf_set, hazard):
        """Cutoff of hazard events which generate damage with a frequency higher
        than hazard_freq_cutoff.

        Parameters
        ----------
        exposures : climada.entity.Exposures
            exposures instance
        imp_set : climada.entity.ImpactFuncSet
            impact function set instance
        hazard : climada.hazard.Hazard
            hazard instance

        Returns
        -------
        new_haz : climada.hazard.Hazard
            Hazard without events which generate damage with a frequency
            higher than hazard_freq_cutoff
        """
        if self.hazard_freq_cutoff == 0:
            return hazard

        if self.exp_region_id:
            # compute impact only in selected region
            in_reg = np.logical_or.reduce([
                exposures.gdf.region_id.values == reg
                for reg in self.exp_region_id
            ])
            exp_imp = Exposures(exposures.gdf[in_reg], crs=exposures.crs)
        else:
            exp_imp = exposures

        from climada.engine.impact import Impact
        imp = Impact()
        imp.calc(exp_imp, impf_set, hazard)

        LOGGER.debug('Cutting events whose damage have a frequency > %s.',
                     self.hazard_freq_cutoff)
        new_haz = copy.deepcopy(hazard)
        sort_idxs = np.argsort(imp.at_event)[::-1]
        exceed_freq = np.cumsum(imp.frequency[sort_idxs])
        cutoff = exceed_freq > self.hazard_freq_cutoff
        sel_haz = sort_idxs[cutoff]
        for row in sel_haz:
            new_haz.intensity.data[new_haz.intensity.indptr[row]:new_haz.
                                   intensity.indptr[row + 1]] = 0
        new_haz.intensity.eliminate_zeros()
        return new_haz
Esempio n. 11
0
    def test_impact_pass(self):
        """Plot impact exceedence frequency curves."""
        myent = Entity.from_excel(ENT_DEMO_TODAY)
        myent.exposures.check()
        myhaz = Hazard.from_mat(HAZ_DEMO_MAT)
        myimp = Impact()
        myimp.calc(myent.exposures, myent.impact_funcs, myhaz)
        ifc = myimp.calc_freq_curve()
        myax = ifc.plot()
        self.assertIn('Exceedance frequency curve', myax.get_title())

        ifc2 = ImpactFreqCurve()
        ifc2.return_per = ifc.return_per
        ifc2.impact = 1.5e11 * np.ones(ifc2.return_per.size)
        ifc2.unit = ''
        ifc2.label = 'prove'
        ifc2.plot(axis=myax)
Esempio n. 12
0
    def test_excel_io(self):
        """Test write and read in excel"""
        ent = Entity.from_excel(ENT_DEMO_TODAY)
        ent.check()

        hazard = Hazard.from_mat(HAZ_TEST_MAT)

        imp_write = Impact()
        ent.exposures.assign_centroids(hazard)
        imp_write.calc(ent.exposures, ent.impact_funcs, hazard)
        file_name = DATA_FOLDER.joinpath('test.xlsx')
        imp_write.write_excel(file_name)

        imp_read = Impact.from_excel(file_name)

        np.testing.assert_array_equal(imp_write.event_id, imp_read.event_id)
        np.testing.assert_array_equal(imp_write.date, imp_read.date)
        np.testing.assert_array_equal(imp_write.coord_exp, imp_read.coord_exp)
        np.testing.assert_array_almost_equal_nulp(imp_write.eai_exp,
                                                  imp_read.eai_exp,
                                                  nulp=5)
        np.testing.assert_array_almost_equal_nulp(imp_write.at_event,
                                                  imp_read.at_event,
                                                  nulp=5)
        np.testing.assert_array_equal(imp_write.frequency, imp_read.frequency)
        self.assertEqual(imp_write.tot_value, imp_read.tot_value)
        self.assertEqual(imp_write.aai_agg, imp_read.aai_agg)
        self.assertEqual(imp_write.unit, imp_read.unit)
        self.assertEqual(
            0,
            len([
                i for i, j in zip(imp_write.event_name, imp_read.event_name)
                if i != j
            ]))
        self.assertIsInstance(imp_read.crs, str)
Esempio n. 13
0
    def _calc_impact(self, new_exp, new_ifs, new_haz):
        """Compute impact and risk transfer of measure implemented over inputs.

        Parameters:
            new_exp (Exposures): exposures once measure applied
            new_ifs (ImpactFuncSet): impact functions once measure applied
            new_haz (Hazard): hazard once measure applied

        Returns:
            Impact, float
        """
        from climada.engine.impact import Impact
        imp = Impact()
        imp.calc(new_exp, new_ifs, new_haz)

        risk_transfer = 0
        if self.risk_transf_attach + self.risk_transf_cover > 0:
            imp_layer = np.minimum(np.maximum(imp.at_event - self.risk_transf_attach, 0),
                                   self.risk_transf_cover)
            risk_transfer = np.sum(imp_layer * imp.frequency)
            imp.at_event = np.maximum(imp.at_event -imp_layer, 0)
            imp.aai_agg = np.sum(imp.at_event * imp.frequency)
            # expected annual impact per exposure no longer valid
            imp.eai_exp = np.array([])

        return imp, risk_transfer
Esempio n. 14
0
    def test_select_event_identity_pass(self):
        """ test select same impact with event name, id and date """

        # Read default entity values
        ent = Entity()
        ent.read_excel(ENT_DEMO_TODAY)
        ent.check()

        # Read default hazard file
        hazard = Hazard('TC')
        hazard.read_mat(HAZ_TEST_MAT)
        # Create impact object
        imp = Impact()

        # Assign centroids to exposures
        ent.exposures.assign_centroids(hazard)

        # Compute the impact over the whole exposures
        imp.calc(ent.exposures, ent.impact_funcs, hazard, save_mat=True)

        sel_imp = imp.select(event_ids=imp.event_id,
                             event_names=imp.event_name,
                             dates=(min(imp.date), max(imp.date)))

        self.assertEqual(sel_imp.crs, imp.crs)
        self.assertEqual(sel_imp.unit, imp.unit)

        self.assertTrue(np.array_equal(sel_imp.event_id, imp.event_id))
        self.assertEqual(sel_imp.event_name, imp.event_name)
        self.assertTrue(np.array_equal(sel_imp.date, imp.date))
        self.assertTrue(np.array_equal(sel_imp.frequency, imp.frequency))

        self.assertTrue(np.array_equal(sel_imp.at_event, imp.at_event))
        self.assertTrue(
            np.array_equal(sel_imp.imp_mat.todense(), imp.imp_mat.todense()))
        self.assertTrue(np.array_equal(sel_imp.eai_exp, imp.eai_exp))
        self.assertAlmostEqual(round(sel_imp.aai_agg, 5),
                               round(imp.aai_agg, 5))

        self.assertEqual(sel_imp.tot_value, imp.tot_value)
        self.assertTrue(np.array_equal(sel_imp.coord_exp, imp.coord_exp))

        self.assertIsInstance(sel_imp, Impact)
        self.assertIsInstance(sel_imp.imp_mat, sparse.csr_matrix)
Esempio n. 15
0
    def test_calc_if_pass(self):
        """Execute when no if_HAZ present, but only if_"""
        ent = Entity()
        ent.read_excel(ENT_DEMO_TODAY)
        ent.exposures.gdf.rename(columns={'if_TC': 'if_'}, inplace=True)
        ent.check()

        # Read default hazard file
        hazard = Hazard('TC')
        hazard.read_mat(HAZ_TEST_MAT)
        # Create impact object
        impact = Impact()
        impact.calc(ent.exposures, ent.impact_funcs, hazard)

        # Check result
        num_events = len(hazard.event_id)
        num_exp = ent.exposures.gdf.shape[0]
        # Check relative errors as well when absolute value gt 1.0e-7
        # impact.at_event == EDS.damage in MATLAB
        self.assertEqual(num_events, len(impact.at_event))
        self.assertEqual(0, impact.at_event[0])
        self.assertEqual(0, impact.at_event[int(num_events / 2)])
        self.assertAlmostEqual(1.472482938320243e+08, impact.at_event[13809])
        self.assertEqual(7.076504723057620e+10, impact.at_event[12147])
        self.assertEqual(0, impact.at_event[num_events - 1])
        # impact.eai_exp == EDS.ED_at_centroid in MATLAB
        self.assertEqual(num_exp, len(impact.eai_exp))
        self.assertAlmostEqual(1.518553670803242e+08, impact.eai_exp[0])
        self.assertAlmostEqual(1.373490457046383e+08,
                               impact.eai_exp[int(num_exp / 2)], 6)
        self.assertTrue(
            np.isclose(1.373490457046383e+08,
                       impact.eai_exp[int(num_exp / 2)]))
        self.assertAlmostEqual(1.066837260150042e+08,
                               impact.eai_exp[num_exp - 1], 6)
        self.assertTrue(
            np.isclose(1.066837260150042e+08,
                       impact.eai_exp[int(num_exp - 1)]))
        # impact.tot_value == EDS.Value in MATLAB
        # impact.aai_agg == EDS.ED in MATLAB
        self.assertAlmostEqual(6.570532945599105e+11, impact.tot_value)
        self.assertAlmostEqual(6.512201157564421e+09, impact.aai_agg, 5)
        self.assertTrue(np.isclose(6.512201157564421e+09, impact.aai_agg))
Esempio n. 16
0
    def test_ref_value_insure_pass(self):
        """Test result against reference value"""
        # Read demo entity values
        # Set the entity default file to the demo one
        ent = Entity()
        ent.read_excel(ENT_DEMO_TODAY)
        ent.check()

        # Read default hazard file
        hazard = Hazard('TC')
        hazard.read_mat(HAZ_TEST_MAT)
        # Create impact object
        impact = Impact()
        impact.at_event = np.zeros(hazard.intensity.shape[0])
        impact.eai_exp = np.zeros(len(ent.exposures.value))
        impact.tot_value = 0

        # Assign centroids to exposures
        ent.exposures.assign_centroids(hazard)

        # Compute impact for 6th exposure
        iexp = 5
        # Take its impact function
        imp_id = ent.exposures.if_TC[iexp]
        imp_fun = ent.impact_funcs.get_func(hazard.tag.haz_type, imp_id)
        # Compute
        insure_flag = True
        impact._exp_impact(np.array([iexp]), ent.exposures, hazard, imp_fun,
                           insure_flag)

        self.assertEqual(impact.eai_exp.size, ent.exposures.shape[0])
        self.assertEqual(impact.at_event.size, hazard.intensity.shape[0])

        events_pos = hazard.intensity[:, ent.exposures.centr_TC[iexp]].nonzero(
        )[0]
        res_exp = np.zeros((ent.exposures.shape[0]))
        res_exp[iexp] = np.sum(impact.at_event[events_pos] *
                               hazard.frequency[events_pos])
        self.assertTrue(np.array_equal(res_exp, impact.eai_exp))

        self.assertEqual(0, impact.at_event[12])
        # Check first 3 values
        self.assertEqual(0, impact.at_event[12])
        self.assertEqual(0, impact.at_event[41])
        self.assertEqual(1.0626600695059455e+06, impact.at_event[44])

        # Check intermediate values
        self.assertEqual(0, impact.at_event[6281])
        self.assertEqual(0, impact.at_event[4998])
        self.assertEqual(0, impact.at_event[9527])
        self.assertEqual(1.3318063850487845e+08, impact.at_event[7192])
        self.assertEqual(4.667108555054083e+06, impact.at_event[8624])

        # Check last 3 values
        self.assertEqual(0, impact.at_event[14349])
        self.assertEqual(0, impact.at_event[14347])
        self.assertEqual(0, impact.at_event[14309])
Esempio n. 17
0
    def test_impact_pass(self):
        """Plot impact exceedence frequency curves."""
        myent = Entity()
        myent.read_excel(ENT_DEMO_TODAY)
        myent.exposures.check()
        myhaz = Hazard('TC')
        myhaz.read_mat(HAZ_DEMO_MAT)
        myimp = Impact()
        myimp.calc(myent.exposures, myent.impact_funcs, myhaz)
        ifc = myimp.calc_freq_curve()
        myfig, _ = ifc.plot()
        self.assertIn('Exceedance frequency curve',\
                      myfig._suptitle.get_text())

        ifc2 = ImpactFreqCurve()
        ifc2.return_per = ifc.return_per
        ifc2.impact = 1.5e11 * np.ones(ifc2.return_per.size)
        ifc2.unit = ''
        ifc2.label = 'prove'
        ifc.plot_compare(ifc2)
Esempio n. 18
0
    def _calc_impact(self, new_exp, new_impfs, new_haz):
        """Compute impact and risk transfer of measure implemented over inputs.

        Parameters
        ----------
        new_exp : climada.entity.Exposures
            exposures once measure applied
        new_ifs : climada.entity.ImpactFuncSet
            impact function set once measure applied
        new_haz  : climada.hazard.Hazard
            hazard once measure applied

        Returns
        -------
            : climada.engine.Impact
        """
        from climada.engine.impact import Impact
        imp = Impact()
        imp.calc(new_exp, new_impfs, new_haz)
        return imp.calc_risk_transfer(self.risk_transf_attach,
                                      self.risk_transf_cover)
Esempio n. 19
0
    def test_local_exceedance_imp_pass(self):
        """Test calc local impacts per return period"""
        # Read default entity values
        ent = Entity.from_excel(ENT_DEMO_TODAY)
        ent.check()

        # Read default hazard file
        hazard = Hazard.from_mat(HAZ_TEST_MAT)

        # Create impact object
        impact = Impact()
        # Assign centroids to exposures
        ent.exposures.assign_centroids(hazard)
        # Compute the impact over the whole exposures
        impact.calc(ent.exposures, ent.impact_funcs, hazard, save_mat=True)
        # Compute the impact per return period over the whole exposures
        impact_rp = impact.local_exceedance_imp(return_periods=(10, 40))

        self.assertIsInstance(impact_rp, np.ndarray)
        self.assertEqual(impact_rp.size, 2 * ent.exposures.gdf.value.size)
        self.assertAlmostEqual(np.max(impact_rp), 2916964966.388219, places=5)
        self.assertAlmostEqual(np.min(impact_rp), 444457580.131494, places=5)
Esempio n. 20
0
    def _calc_impact_measures(self,
                              hazard,
                              exposures,
                              meas_set,
                              imp_fun_set,
                              when='future',
                              risk_func=risk_aai_agg,
                              save_imp=False):
        """Compute impact of each measure and transform it to input risk
        measurement. Set reference year from exposures value.

        Parameters:
            hazard (Hazard): hazard.
            exposures (Exposures): exposures.
            meas_set (MeasureSet): set of measures.
            imp_fun_set (ImpactFuncSet): set of impact functions.
            when (str, optional): 'present' or 'future'. The conditions that
                are being considered.
            risk_func (function, optional): function used to transform impact
                to a risk measurement.
            save_imp (bool, optional): activate if Impact of each measure is
                saved. Default: False.
        """
        impact_meas = dict()

        # compute impact without measures
        LOGGER.debug('%s impact with no measure.', when)
        imp_tmp = Impact()
        imp_tmp.calc(exposures, imp_fun_set, hazard)
        impact_meas[NO_MEASURE] = dict()
        impact_meas[NO_MEASURE]['cost'] = (0, 0)
        impact_meas[NO_MEASURE]['risk'] = risk_func(imp_tmp)
        impact_meas[NO_MEASURE]['risk_transf'] = 0.0
        impact_meas[NO_MEASURE]['efc'] = imp_tmp.calc_freq_curve()
        if save_imp:
            impact_meas[NO_MEASURE]['impact'] = imp_tmp

        # compute impact for each measure
        for measure in meas_set.get_measure(hazard.tag.haz_type):
            LOGGER.debug('%s impact of measure %s.', when, measure.name)
            imp_tmp, risk_transf = measure.calc_impact(exposures, imp_fun_set,
                                                       hazard)
            impact_meas[measure.name] = dict()
            impact_meas[measure.name]['cost'] = (
                measure.cost, measure.risk_transf_cost_factor)
            impact_meas[measure.name]['risk'] = risk_func(imp_tmp)
            impact_meas[measure.name]['risk_transf'] = risk_func(risk_transf)
            impact_meas[measure.name]['efc'] = imp_tmp.calc_freq_curve()
            if save_imp:
                impact_meas[measure.name]['impact'] = imp_tmp

        # if present reference provided save it
        if when == 'future':
            self.imp_meas_future = impact_meas
        else:
            self.imp_meas_present = impact_meas
Esempio n. 21
0
    def _calc_impact_measures(self, hazard, exposures, meas_set, imp_fun_set,
                              when='future', risk_func=risk_aai_agg, save_imp=False):
        """Compute impact of each measure and transform it to input risk
        measurement. Set reference year from exposures value.

        Parameters
        ----------
        hazard : climada.Hazard
        exposures : climada.entity.Exposures
        meas_set : climada.MeasureSet
            set of measures.
        imp_fun_set : ImpactFuncSet
            set of impact functions.
        when : str, optional
            'present' or 'future'. The conditions that
            are being considered.
        risk_func : func, optional
            function describing risk measure given an Impact.
            Default: average annual impact (aggregated).
        save_imp : bool, optional
            activate if Impact of each measure is
            saved. Default: False.
        """
        impact_meas = dict()

        # compute impact without measures
        LOGGER.debug('%s impact with no measure.', when)
        imp_tmp = Impact()
        imp_tmp.calc(exposures, imp_fun_set, hazard)
        impact_meas[NO_MEASURE] = dict()
        impact_meas[NO_MEASURE]['cost'] = (0, 0)
        impact_meas[NO_MEASURE]['risk'] = risk_func(imp_tmp)
        impact_meas[NO_MEASURE]['risk_transf'] = 0.0
        impact_meas[NO_MEASURE]['efc'] = imp_tmp.calc_freq_curve()
        if save_imp:
            impact_meas[NO_MEASURE]['impact'] = imp_tmp

        # compute impact for each measure
        for measure in meas_set.get_measure(hazard.tag.haz_type):
            LOGGER.debug('%s impact of measure %s.', when, measure.name)
            imp_tmp, risk_transf = measure.calc_impact(exposures, imp_fun_set, hazard)
            impact_meas[measure.name] = dict()
            impact_meas[measure.name]['cost'] = (measure.cost, measure.risk_transf_cost_factor)
            impact_meas[measure.name]['risk'] = risk_func(imp_tmp)
            impact_meas[measure.name]['risk_transf'] = risk_func(risk_transf)
            impact_meas[measure.name]['efc'] = imp_tmp.calc_freq_curve()
            if save_imp:
                impact_meas[measure.name]['impact'] = imp_tmp

        # if present reference provided save it
        if when == 'future':
            self.imp_meas_future = impact_meas
        else:
            self.imp_meas_present = impact_meas
Esempio n. 22
0
    def plot_waterfall_accumulated(self,
                                   hazard,
                                   entity,
                                   ent_future,
                                   risk_func=risk_aai_agg,
                                   imp_time_depen=1,
                                   axis=None,
                                   **kwargs):
        """ Plot waterfall graph with accumulated values from present to future
        year. Call after calc() with save_imp=True. Provide same inputs as in calc.

        Parameters:
            hazard (Hazard): hazard
            entity (Entity): entity
            ent_future (Entity): entity in the future
            risk_func (func, optional): function describing risk measure given
                an Impact. Default: average annual impact (aggregated).
            imp_time_depen (float, optional): parameter which represent time
                evolution of impact. Default: 1 (linear).
            axis (matplotlib.axes._subplots.AxesSubplot, optional): axis to use
            kwargs (optional): arguments for bar matplotlib function, e.g. alpha=0.5

        Returns:
            matplotlib.axes._subplots.AxesSubplot
        """
        if not self.imp_meas_future or not self.imp_meas_present:
            LOGGER.error('Compute CostBenefit.calc() first')
            raise ValueError
        if ent_future.exposures.ref_year == entity.exposures.ref_year:
            LOGGER.error(
                'Same reference years for future and present entities.')
            raise ValueError

        self.present_year = entity.exposures.ref_year
        self.future_year = ent_future.exposures.ref_year

        # current situation
        curr_risk = self.imp_meas_present[NO_MEASURE]['risk']
        time_dep = self._time_dependency_array()
        risk_curr = self._npv_unaverted_impact(curr_risk, entity.disc_rates,
                                               time_dep)
        LOGGER.info('Current total risk at {:d}: {:.3e}'.format(
            self.future_year, risk_curr))

        # changing future
        time_dep = self._time_dependency_array(imp_time_depen)
        # socio-economic dev
        imp = Impact()
        imp.calc(ent_future.exposures, ent_future.impact_funcs, hazard)
        risk_dev = self._npv_unaverted_impact(risk_func(imp),
                                              entity.disc_rates, time_dep,
                                              curr_risk)
        LOGGER.info('Total risk with development at {:d}: {:.3e}'.format( \
            self.future_year, risk_dev))

        # socioecon + cc
        risk_tot = self._npv_unaverted_impact(self.imp_meas_future[NO_MEASURE]['risk'], \
            entity.disc_rates, time_dep, curr_risk)
        LOGGER.info('Total risk with development and climate change at {:d}: {:.3e}'.\
            format(self.future_year, risk_tot))

        # plot
        if not axis:
            _, axis = plt.subplots(1, 1)
        norm_fact, norm_name = _norm_values(curr_risk)
        axis.bar(1, risk_curr / norm_fact, **kwargs)
        axis.text(1, risk_curr/norm_fact, str(int(round(risk_curr/norm_fact))), \
            horizontalalignment='center', verticalalignment='bottom', \
            fontsize=12, color='k')
        axis.bar(2,
                 height=(risk_dev - risk_curr) / norm_fact,
                 bottom=risk_curr / norm_fact,
                 **kwargs)
        axis.text(2, risk_curr/norm_fact + (risk_dev-risk_curr)/norm_fact/2, \
            str(int(round((risk_dev-risk_curr)/norm_fact))), \
            horizontalalignment='center', verticalalignment='center', fontsize=12, color='k')
        axis.bar(3,
                 height=(risk_tot - risk_dev) / norm_fact,
                 bottom=risk_dev / norm_fact,
                 **kwargs)
        axis.text(3, risk_dev/norm_fact + (risk_tot-risk_dev)/norm_fact/2, \
            str(int(round((risk_tot-risk_dev)/norm_fact))), \
            horizontalalignment='center', verticalalignment='center', fontsize=12, color='k')
        axis.bar(4, height=risk_tot / norm_fact, **kwargs)
        axis.text(4, risk_tot/norm_fact, str(int(round(risk_tot/norm_fact))), \
                  horizontalalignment='center', verticalalignment='bottom', \
                  fontsize=12, color='k')

        axis.set_xticks(np.arange(4) + 1)
        axis.set_xticklabels(['Risk ' + str(self.present_year), \
            'Economic \ndevelopment', 'Climate \nchange', 'Risk ' + str(self.future_year)])
        axis.set_ylabel('Impact (' + self.unit + ' ' + norm_name + ')')
        axis.set_title('Total accumulated impact from {:d} to {:d}'.format( \
                       self.present_year, self.future_year))
        return axis
Esempio n. 23
0
    def plot_waterfall(hazard,
                       entity,
                       haz_future,
                       ent_future,
                       risk_func=risk_aai_agg,
                       axis=None,
                       **kwargs):
        """ Plot waterfall graph at future with given risk metric. Can be called
        before and after calc().

        Parameters:
            hazard (Hazard): hazard
            entity (Entity): entity
            haz_future (Hazard): hazard in the future (future year provided at
                ent_future)
            ent_future (Entity): entity in the future
            risk_func (func, optional): function describing risk measure given
                an Impact. Default: average annual impact (aggregated).
            axis (matplotlib.axes._subplots.AxesSubplot, optional): axis to use
            kwargs (optional): arguments for bar matplotlib function, e.g. alpha=0.5

        Returns:
            matplotlib.axes._subplots.AxesSubplot
        """
        if ent_future.exposures.ref_year == entity.exposures.ref_year:
            LOGGER.error(
                'Same reference years for future and present entities.')
            raise ValueError
        present_year = entity.exposures.ref_year
        future_year = ent_future.exposures.ref_year

        imp = Impact()
        imp.calc(entity.exposures, entity.impact_funcs, hazard)
        curr_risk = risk_func(imp)

        imp = Impact()
        imp.calc(ent_future.exposures, ent_future.impact_funcs, haz_future)
        fut_risk = risk_func(imp)

        if not axis:
            _, axis = plt.subplots(1, 1)
        norm_fact, norm_name = _norm_values(curr_risk)

        # current situation
        LOGGER.info('Risk at {:d}: {:.3e}'.format(present_year, curr_risk))

        # changing future
        # socio-economic dev
        imp = Impact()
        imp.calc(ent_future.exposures, ent_future.impact_funcs, hazard)
        risk_dev = risk_func(imp)
        LOGGER.info('Risk with development at {:d}: {:.3e}'.format(
            future_year, risk_dev))

        # socioecon + cc
        LOGGER.info('Risk with development and climate change at {:d}: {:.3e}'.\
                    format(future_year, fut_risk))

        axis.bar(1, curr_risk / norm_fact, **kwargs)
        axis.text(1, curr_risk/norm_fact, str(int(round(curr_risk/norm_fact))), \
            horizontalalignment='center', verticalalignment='bottom', \
            fontsize=12, color='k')
        axis.bar(2,
                 height=(risk_dev - curr_risk) / norm_fact,
                 bottom=curr_risk / norm_fact,
                 **kwargs)
        axis.text(2, curr_risk/norm_fact + (risk_dev-curr_risk)/norm_fact/2, \
            str(int(round((risk_dev-curr_risk)/norm_fact))), \
            horizontalalignment='center', verticalalignment='center', fontsize=12, color='k')
        axis.bar(3,
                 height=(fut_risk - risk_dev) / norm_fact,
                 bottom=risk_dev / norm_fact,
                 **kwargs)
        axis.text(3, risk_dev/norm_fact + (fut_risk-risk_dev)/norm_fact/2, \
            str(int(round((fut_risk-risk_dev)/norm_fact))), \
            horizontalalignment='center', verticalalignment='center', fontsize=12, color='k')
        axis.bar(4, height=fut_risk / norm_fact, **kwargs)
        axis.text(4, fut_risk/norm_fact, str(int(round(fut_risk/norm_fact))), \
                  horizontalalignment='center', verticalalignment='bottom', \
                  fontsize=12, color='k')

        axis.set_xticks(np.arange(4) + 1)
        axis.set_xticklabels(['Risk ' + str(present_year), \
            'Economic \ndevelopment', 'Climate \nchange', 'Risk ' + str(future_year)])
        axis.set_ylabel('Impact (' + imp.unit + ' ' + norm_name + ')')
        axis.set_title('Risk at {:d} and {:d}'.format(present_year,
                                                      future_year))
        return axis
Esempio n. 24
0
    def test_ref_value_rp_pass(self):
        """Test result against reference value with given return periods"""
        imp = Impact()
        imp.frequency = np.ones(10) * 6.211180124223603e-04
        imp.at_event = np.zeros(10)
        imp.at_event[0] = 0
        imp.at_event[1] = 0.400665463736549e9
        imp.at_event[2] = 3.150330960044466e9
        imp.at_event[3] = 3.715826406781887e9
        imp.at_event[4] = 2.900244271902339e9
        imp.at_event[5] = 0.778570745161971e9
        imp.at_event[6] = 0.698736262566472e9
        imp.at_event[7] = 0.381063674256423e9
        imp.at_event[8] = 0.569142464157450e9
        imp.at_event[9] = 0.467572545849132e9
        imp.unit = 'USD'

        ifc = imp.calc_freq_curve(np.array([100, 500, 1000]))
        self.assertEqual(3, len(ifc.return_per))
        self.assertEqual(100, ifc.return_per[0])
        self.assertEqual(500, ifc.return_per[1])
        self.assertEqual(1000, ifc.return_per[2])
        self.assertEqual(3, len(ifc.impact))
        self.assertEqual(0, ifc.impact[0])
        self.assertEqual(2320408028.5695677, ifc.impact[1])
        self.assertEqual(3287314329.129928, ifc.impact[2])
        self.assertEqual('Exceedance frequency curve', ifc.label)
        self.assertEqual('USD', ifc.unit)
Esempio n. 25
0
    def test_risk_trans_pass(self):
        """Test calc_risk_transfer"""
        # Create impact object
        imp = Impact()
        imp.event_id = np.arange(10)
        imp.event_name = [0, 1, 2, 3, 4, 5, 6, 7, 8, 15]
        imp.date = np.arange(10)
        imp.coord_exp = np.array([[1, 2], [2, 3]])
        imp.crs = DEF_CRS
        imp.eai_exp = np.array([1, 2])
        imp.at_event = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 15])
        imp.frequency = np.ones(10) / 5
        imp.tot_value = 10
        imp.aai_agg = 100
        imp.unit = 'USD'
        imp.imp_mat = sparse.csr_matrix(np.empty((0, 0)))

        new_imp, imp_rt = imp.calc_risk_transfer(2, 10)
        self.assertEqual(new_imp.unit, imp.unit)
        self.assertEqual(new_imp.tot_value, imp.tot_value)
        self.assertTrue((new_imp.imp_mat == imp.imp_mat).toarray().all())
        self.assertEqual(new_imp.event_name, imp.event_name)
        self.assertTrue(np.allclose(new_imp.event_id, imp.event_id))
        self.assertTrue(np.allclose(new_imp.date, imp.date))
        self.assertTrue(np.allclose(new_imp.frequency, imp.frequency))
        self.assertTrue(np.allclose(new_imp.coord_exp, np.array([])))
        self.assertTrue(np.allclose(new_imp.eai_exp, np.array([])))
        self.assertTrue(
            np.allclose(new_imp.at_event,
                        np.array([0, 1, 2, 2, 2, 2, 2, 2, 2, 5])))
        self.assertAlmostEqual(new_imp.aai_agg, 4.0)

        self.assertEqual(imp_rt.unit, imp.unit)
        self.assertEqual(imp_rt.tot_value, imp.tot_value)
        self.assertTrue((imp_rt.imp_mat == imp.imp_mat).toarray().all())
        self.assertEqual(imp_rt.event_name, imp.event_name)
        self.assertTrue(np.allclose(imp_rt.event_id, imp.event_id))
        self.assertTrue(np.allclose(imp_rt.date, imp.date))
        self.assertTrue(np.allclose(imp_rt.frequency, imp.frequency))
        self.assertTrue(np.allclose(imp_rt.coord_exp, np.array([])))
        self.assertTrue(np.allclose(imp_rt.eai_exp, np.array([])))
        self.assertTrue(
            np.allclose(imp_rt.at_event,
                        np.array([0, 0, 0, 1, 2, 3, 4, 5, 6, 10])))
        self.assertAlmostEqual(imp_rt.aai_agg, 6.2)
Esempio n. 26
0
    def test_write_imp_mat(self):
        """Test write_excel_imp_mat function"""
        impact = Impact()
        impact.imp_mat = np.zeros((5, 4))
        impact.imp_mat[0, :] = np.arange(4)
        impact.imp_mat[1, :] = np.arange(4) * 2
        impact.imp_mat[2, :] = np.arange(4) * 3
        impact.imp_mat[3, :] = np.arange(4) * 4
        impact.imp_mat[4, :] = np.arange(4) * 5
        impact.imp_mat = sparse.csr_matrix(impact.imp_mat)

        file_name = os.path.join(DATA_FOLDER, 'test_imp_mat')
        impact.write_sparse_csr(file_name)
        read_imp_mat = Impact().read_sparse_csr(file_name + '.npz')
        for irow in range(5):
            self.assertTrue(
                np.array_equal(
                    np.array(read_imp_mat[irow, :].toarray()).reshape(-1),
                    np.array(impact.imp_mat[irow, :].toarray()).reshape(-1)))
Esempio n. 27
0
    def test_write_read_exp_test(self):
        """Test result against reference value"""
        # Create impact object
        num_ev = 5
        num_exp = 10
        imp_write = Impact()
        imp_write.tag = {
            'exp': Tag('file_exp.p', 'descr exp'),
            'haz': TagHaz('TC', 'file_haz.p', 'descr haz'),
            'if_set': Tag()
        }
        imp_write.event_id = np.arange(num_ev)
        imp_write.event_name = [
            'event_' + str(num) for num in imp_write.event_id
        ]
        imp_write.date = np.ones(num_ev)
        imp_write.coord_exp = np.zeros((num_exp, 2))
        imp_write.coord_exp[:, 0] = 1.5
        imp_write.coord_exp[:, 1] = 2.5
        imp_write.eai_exp = np.arange(num_exp) * 100
        imp_write.at_event = np.arange(num_ev) * 50
        imp_write.frequency = np.ones(num_ev) * 0.1
        imp_write.tot_value = 1000
        imp_write.aai_agg = 1001
        imp_write.unit = 'USD'

        file_name = os.path.join(DATA_FOLDER, 'test.csv')
        imp_write.write_csv(file_name)

        imp_read = Impact()
        imp_read.read_csv(file_name)
        self.assertTrue(np.array_equal(imp_write.event_id, imp_read.event_id))
        self.assertTrue(np.array_equal(imp_write.date, imp_read.date))
        self.assertTrue(np.array_equal(imp_write.coord_exp,
                                       imp_read.coord_exp))
        self.assertTrue(np.array_equal(imp_write.eai_exp, imp_read.eai_exp))
        self.assertTrue(np.array_equal(imp_write.at_event, imp_read.at_event))
        self.assertTrue(np.array_equal(imp_write.frequency,
                                       imp_read.frequency))
        self.assertEqual(imp_write.tot_value, imp_read.tot_value)
        self.assertEqual(imp_write.aai_agg, imp_read.aai_agg)
        self.assertEqual(imp_write.unit, imp_read.unit)
        self.assertEqual(
            0,
            len([
                i for i, j in zip(imp_write.event_name, imp_read.event_name)
                if i != j
            ]))
        self.assertIsInstance(imp_read.crs, dict)
Esempio n. 28
0
    def test_ref_value_pass(self):
        """Test result against reference value"""
        imp = Impact()
        imp.frequency = np.ones(10) * 6.211180124223603e-04
        imp.at_event = np.zeros(10)
        imp.at_event[0] = 0
        imp.at_event[1] = 0.400665463736549e9
        imp.at_event[2] = 3.150330960044466e9
        imp.at_event[3] = 3.715826406781887e9
        imp.at_event[4] = 2.900244271902339e9
        imp.at_event[5] = 0.778570745161971e9
        imp.at_event[6] = 0.698736262566472e9
        imp.at_event[7] = 0.381063674256423e9
        imp.at_event[8] = 0.569142464157450e9
        imp.at_event[9] = 0.467572545849132e9
        imp.unit = 'USD'

        ifc = imp.calc_freq_curve()
        self.assertEqual(10, len(ifc.return_per))
        self.assertEqual(1610.0000000000000, ifc.return_per[9])
        self.assertEqual(805.00000000000000, ifc.return_per[8])
        self.assertEqual(536.66666666666663, ifc.return_per[7])
        self.assertEqual(402.500000000000, ifc.return_per[6])
        self.assertEqual(322.000000000000, ifc.return_per[5])
        self.assertEqual(268.33333333333331, ifc.return_per[4])
        self.assertEqual(230.000000000000, ifc.return_per[3])
        self.assertEqual(201.250000000000, ifc.return_per[2])
        self.assertEqual(178.88888888888889, ifc.return_per[1])
        self.assertEqual(161.000000000000, ifc.return_per[0])
        self.assertEqual(10, len(ifc.impact))
        self.assertEqual(3.715826406781887e9, ifc.impact[9])
        self.assertEqual(3.150330960044466e9, ifc.impact[8])
        self.assertEqual(2.900244271902339e9, ifc.impact[7])
        self.assertEqual(0.778570745161971e9, ifc.impact[6])
        self.assertEqual(0.698736262566472e9, ifc.impact[5])
        self.assertEqual(0.569142464157450e9, ifc.impact[4])
        self.assertEqual(0.467572545849132e9, ifc.impact[3])
        self.assertEqual(0.400665463736549e9, ifc.impact[2])
        self.assertEqual(0.381063674256423e9, ifc.impact[1])
        self.assertEqual(0, ifc.impact[0])
        self.assertEqual('Exceedance frequency curve', ifc.label)
        self.assertEqual('USD', ifc.unit)
Esempio n. 29
0
    def test_impact_year_set_sum(self):
        """Test result against reference value with given events"""
        imp = Impact()
        imp.frequency = np.ones(10) * 6.211180124223603e-04
        imp.at_event = np.zeros(10)
        imp.at_event[0] = 0
        imp.at_event[1] = 0.400665463736549e9
        imp.at_event[2] = 3.150330960044466e9
        imp.at_event[3] = 3.715826406781887e9
        imp.at_event[4] = 2.900244271902339e9
        imp.at_event[5] = 0.778570745161971e9
        imp.at_event[6] = 0.698736262566472e9
        imp.at_event[7] = 0.381063674256423e9
        imp.at_event[8] = 0.569142464157450e9
        imp.at_event[9] = 0.467572545849132e9
        imp.unit = 'USD'
        imp.date = np.array([
            732801, 716160, 718313, 712468, 732802, 729285, 732931, 715419,
            722404, 718351
        ])

        iys_all = imp.calc_impact_year_set()
        iys = imp.calc_impact_year_set(all_years=False)
        iys_all_yr = imp.calc_impact_year_set(year_range=(1975, 2000))
        iys_yr = imp.calc_impact_year_set(all_years=False,
                                          year_range=[1975, 2000])
        iys_all_yr_1940 = imp.calc_impact_year_set(all_years=True,
                                                   year_range=[1940, 2000])
        self.assertEqual(np.around(sum([iys[year] for year in iys])),
                         np.around(sum(imp.at_event)))
        self.assertEqual(sum([iys[year] for year in iys]),
                         sum([iys_all[year] for year in iys_all]))
        self.assertEqual(len(iys), 7)
        self.assertEqual(len(iys_all), 57)
        self.assertIn(1951 and 1959 and 2007, iys_all)
        self.assertTrue(iys_all[1959] > 0)
        self.assertAlmostEqual(3598980534.468811, iys_all[2007])
        self.assertEqual(iys[1978], iys_all[1978])
        self.assertAlmostEqual(iys[1951], imp.at_event[3])
        # year range (yr):
        self.assertEqual(len(iys_yr), 2)
        self.assertEqual(len(iys_all_yr), 26)
        self.assertEqual(sum([iys_yr[year] for year in iys_yr]),
                         sum([iys_all_yr[year] for year in iys_all_yr]))
        self.assertIn(1997 and 1978, iys_yr)
        self.assertFalse(2007 in iys_yr)
        self.assertFalse(1959 in iys_yr)
        self.assertEqual(len(iys_all_yr_1940), 61)
Esempio n. 30
0
def dummy_impact():

    imp = Impact()
    imp.event_id = np.arange(6)
    imp.event_name = [0, 1, 'two', 'three', 30, 31]
    imp.date = np.arange(6)
    imp.coord_exp = np.array([[1, 2], [1.5, 2.5]])
    imp.crs = DEF_CRS
    imp.eai_exp = np.array([7.2, 7.2])
    imp.at_event = np.array([0, 2, 4, 6, 60, 62])
    imp.frequency = np.array([1 / 6, 1 / 6, 1, 1, 1 / 30, 1 / 30])
    imp.tot_value = 7
    imp.aai_agg = 14.4
    imp.unit = 'USD'
    imp.imp_mat = sparse.csr_matrix(
        np.array([[0, 0], [1, 1], [2, 2], [3, 3], [30, 30], [31, 31]]))

    return imp