def test_calc_cb_no_change_pass(self):
"""Test _calc_cost_benefit without present value against reference value"""
hazard = Hazard('TC')
hazard.read_mat(HAZ_TEST_MAT)
entity = Entity()
entity.read_mat(ENT_TEST_MAT)
entity.measures._data['TC'] = entity.measures._data.pop('XX')
for meas in entity.measures.get_measure('TC'):
meas.haz_type = 'TC'
entity.check()
cost_ben = CostBenefit()
cost_ben._calc_impact_measures(hazard, entity.exposures, entity.measures,
entity.impact_funcs, when='future', risk_func=risk_aai_agg, save_imp=True)
cost_ben.present_year = 2018
cost_ben.future_year = 2040
cost_ben._calc_cost_benefit(entity.disc_rates)
self.assertEqual(cost_ben.imp_meas_present, dict())
self.assertEqual(len(cost_ben.imp_meas_future), 5)
self.assertEqual(cost_ben.present_year, 2018)
self.assertEqual(cost_ben.future_year, 2040)
self.assertEqual(cost_ben.cost_ben_ratio['Mangroves'], 0.04230714690616641)
self.assertEqual(cost_ben.cost_ben_ratio['Beach nourishment'], 0.06998836431681373)
self.assertEqual(cost_ben.cost_ben_ratio['Seawall'], 0.2679741183248266)
self.assertEqual(cost_ben.cost_ben_ratio['Building code'], 0.30286828677985717)
self.assertEqual(cost_ben.benefit['Mangroves'], 3.100583368954022e+10)
self.assertEqual(cost_ben.benefit['Beach nourishment'], 2.468981832719974e+10)
self.assertEqual(cost_ben.benefit['Seawall'], 3.3132973770502796e+10)
self.assertEqual(cost_ben.benefit['Building code'], 3.0376240767284798e+10)
self.assertEqual(cost_ben.tot_climate_risk, 1.2150496306913972e+11)
def test_read_mat(self):
"""Read entity from mat file produced by climada."""
entity_mat = Entity()
entity_mat.read_mat(ENT_TEST_MAT)
self.assertEqual(entity_mat.exposures.tag.file_name, ENT_TEST_MAT)
self.assertEqual(entity_mat.disc_rates.tag.file_name, ENT_TEST_MAT)
self.assertEqual(entity_mat.measures.tag.file_name, ENT_TEST_MAT)
self.assertEqual(entity_mat.impact_funcs.tag.file_name, ENT_TEST_MAT)
def test_calc_cb_change_pass(self):
"""Test _calc_cost_benefit with present value against reference value"""
hazard = Hazard('TC')
hazard.read_mat(HAZ_TEST_MAT)
entity = Entity()
entity.read_mat(ENT_TEST_MAT)
entity.measures._data['TC'] = entity.measures._data.pop('XX')
for meas in entity.measures.get_measure('TC'):
meas.haz_type = 'TC'
entity.check()
cost_ben = CostBenefit()
cost_ben._calc_impact_measures(hazard, entity.exposures, entity.measures,
entity.impact_funcs, when='present', risk_func=risk_aai_agg, save_imp=False)
ent_future = Entity()
ent_future.read_excel(ENT_DEMO_FUTURE)
ent_future.check()
haz_future = copy.deepcopy(hazard)
haz_future.intensity.data += 25
cost_ben._calc_impact_measures(haz_future, ent_future.exposures, ent_future.measures,
ent_future.impact_funcs, when='future', risk_func=risk_aai_agg, save_imp=False)
cost_ben.present_year = 2018
cost_ben.future_year = 2040
cost_ben._calc_cost_benefit(entity.disc_rates, imp_time_depen=1)
self.assertEqual(cost_ben.present_year, 2018)
self.assertEqual(cost_ben.future_year, 2040)
self.assertEqual(cost_ben.tot_climate_risk, 5.768659152882021e+11)
self.assertEqual(cost_ben.imp_meas_present['no measure']['risk'], 6.51220115756442e+09)
self.assertEqual(cost_ben.imp_meas_present['Mangroves']['risk'], 4.850407096284983e+09)
self.assertEqual(cost_ben.imp_meas_present['Beach nourishment']['risk'], 5.188921355413834e+09)
self.assertEqual(cost_ben.imp_meas_present['Seawall']['risk'], 4.736400526119911e+09)
self.assertEqual(cost_ben.imp_meas_present['Building code']['risk'], 4.884150868173321e+09)
self.assertEqual(cost_ben.imp_meas_future['no measure']['risk'], 5.9506659786664024e+10)
self.assertEqual(cost_ben.imp_meas_future['Mangroves']['risk'], 4.826231151473135e+10)
self.assertEqual(cost_ben.imp_meas_future['Beach nourishment']['risk'], 5.0647250923231674e+10)
self.assertEqual(cost_ben.imp_meas_future['Seawall']['risk'], 21089567135.7345)
self.assertEqual(cost_ben.imp_meas_future['Building code']['risk'], 4.462999483999791e+10)
self.assertAlmostEqual(cost_ben.benefit['Mangroves'], 113345027690.81276)
self.assertAlmostEqual(cost_ben.benefit['Beach nourishment'], 89444869971.53653)
self.assertAlmostEqual(cost_ben.benefit['Seawall'], 347977469896.1333)
self.assertAlmostEqual(cost_ben.benefit['Building code'], 144216478822.05154)
self.assertAlmostEqual(cost_ben.cost_ben_ratio['Mangroves'], 0.011573232523528404)
self.assertAlmostEqual(cost_ben.cost_ben_ratio['Beach nourishment'], 0.01931916274851638)
self.assertAlmostEqual(cost_ben.cost_ben_ratio['Seawall'], 0.025515385913577368)
self.assertAlmostEqual(cost_ben.cost_ben_ratio['Building code'], 0.06379298728650741)
self.assertEqual(cost_ben.tot_climate_risk, 576865915288.2021)
def test_calc_impact_transf_pass(self):
""" Test calc_impact method: apply all measures and insurance """
hazard = Hazard('TC')
hazard.read_mat(HAZ_TEST_MAT)
entity = Entity()
entity.read_mat(ENT_TEST_MAT)
entity.exposures.rename(columns={'if_': 'if_TC'}, inplace=True)
entity.measures._data['TC'] = entity.measures._data.pop('XX')
for meas in entity.measures.get_measure('TC'):
meas.haz_type = 'TC'
meas = entity.measures.get_measure(name='Beach nourishment',
haz_type='TC')
meas.haz_type = 'TC'
meas.hazard_inten_imp = (1, 0)
meas.mdd_impact = (1, 0)
meas.paa_impact = (1, 0)
meas.risk_transf_attach = 5.0e8
meas.risk_transf_cover = 1.0e9
entity.check()
imp, risk_transf = entity.measures.get_measure(
name='Beach nourishment',
haz_type='TC').calc_impact(entity.exposures, entity.impact_funcs,
hazard)
self.assertAlmostEqual(imp.aai_agg, 6.280804242609713e+09)
self.assertAlmostEqual(imp.at_event[0], 0)
self.assertAlmostEqual(imp.at_event[12], 8.648764833437817e+07)
self.assertAlmostEqual(imp.at_event[41], 500000000)
self.assertAlmostEqual(imp.at_event[11890], 6.498096646836635e+07)
self.assertTrue(
np.array_equal(imp.coord_exp[:, 0], entity.exposures.latitude))
self.assertTrue(
np.array_equal(imp.coord_exp[:, 1], entity.exposures.longitude))
self.assertTrue(np.array_equal(imp.eai_exp, np.array([])))
self.assertAlmostEqual(imp.tot_value, 6.570532945599105e+11)
self.assertEqual(imp.unit, 'USD')
self.assertEqual(imp.imp_mat, [])
self.assertTrue(np.array_equal(imp.event_id, hazard.event_id))
self.assertTrue(np.array_equal(imp.date, hazard.date))
self.assertEqual(imp.event_name, hazard.event_name)
self.assertEqual(imp.tag['exp'].file_name,
entity.exposures.tag.file_name)
self.assertEqual(imp.tag['haz'].file_name, hazard.tag.file_name)
self.assertEqual(imp.tag['if_set'].file_name,
entity.impact_funcs.tag.file_name)
self.assertEqual(risk_transf, 2.3139691495470852e+08)
def test_calc_impact_pass(self):
"""Test calc_impact method: apply all measures but insurance"""
hazard = Hazard('TC')
hazard.read_mat(HAZ_TEST_MAT)
entity = Entity()
entity.read_mat(ENT_TEST_MAT)
entity.exposures.gdf.rename(columns={'if_': 'if_TC'}, inplace=True)
entity.measures._data['TC'] = entity.measures._data.pop('XX')
entity.measures.get_measure(name='Mangroves',
haz_type='TC').haz_type = 'TC'
for meas in entity.measures.get_measure('TC'):
meas.haz_type = 'TC'
entity.check()
imp, risk_transf = entity.measures.get_measure(
'TC', 'Mangroves').calc_impact(entity.exposures,
entity.impact_funcs, hazard)
self.assertAlmostEqual(imp.aai_agg, 4.850407096284983e+09)
self.assertAlmostEqual(imp.at_event[0], 0)
self.assertAlmostEqual(imp.at_event[12], 1.470194187501225e+07)
self.assertAlmostEqual(imp.at_event[41], 4.7226357936631286e+08)
self.assertAlmostEqual(imp.at_event[11890], 1.742110428135755e+07)
self.assertTrue(
np.array_equal(imp.coord_exp[:, 0], entity.exposures.gdf.latitude))
self.assertTrue(
np.array_equal(imp.coord_exp[:, 1],
entity.exposures.gdf.longitude))
self.assertAlmostEqual(imp.eai_exp[0], 1.15677655725858e+08)
self.assertAlmostEqual(imp.eai_exp[-1], 7.528669956120645e+07)
self.assertAlmostEqual(imp.tot_value, 6.570532945599105e+11)
self.assertEqual(imp.unit, 'USD')
self.assertEqual(imp.imp_mat.shape, (0, 0))
self.assertTrue(np.array_equal(imp.event_id, hazard.event_id))
self.assertTrue(np.array_equal(imp.date, hazard.date))
self.assertEqual(imp.event_name, hazard.event_name)
self.assertEqual(imp.tag['exp'].file_name,
entity.exposures.tag.file_name)
self.assertEqual(imp.tag['haz'].file_name, hazard.tag.file_name)
self.assertEqual(imp.tag['if_set'].file_name,
entity.impact_funcs.tag.file_name)
self.assertEqual(risk_transf.aai_agg, 0)
def test_apply_ref_pass(self):
"""Test apply method: apply all measures but insurance"""
hazard = Hazard('TC')
hazard.read_mat(HAZ_TEST_MAT)
hazard.haz_type = 'TC'
entity = Entity()
entity.read_mat(ENT_TEST_MAT)
entity.measures._data['TC'] = entity.measures._data.pop('XX')
for meas in entity.measures.get_measure('TC'):
meas.haz_type = 'TC'
entity.check()
new_exp, new_ifs, new_haz = entity.measures.get_measure('TC', 'Mangroves').apply(entity.exposures,
entity.impact_funcs, hazard)
self.assertTrue(new_exp is entity.exposures)
self.assertTrue(new_haz is hazard)
self.assertFalse(new_ifs is entity.impact_funcs)
new_imp = new_ifs.get_func('TC')[0]
self.assertTrue(np.array_equal(new_imp.intensity, np.array([4., 24., 34., 44.,
54., 64., 74., 84., 104.])))
self.assertTrue(np.allclose(new_imp.mdd, np.array([0, 0, 0.021857142857143, 0.035887500000000,
0.053977415307403, 0.103534246575342, 0.180414000000000, 0.410796000000000, 0.410796000000000])))
self.assertTrue(np.allclose(new_imp.paa, np.array([0, 0.005000000000000, 0.042000000000000,
0.160000000000000, 0.398500000000000, 0.657000000000000, 1.000000000000000,
1.000000000000000, 1.000000000000000])))
new_imp = new_ifs.get_func('TC')[1]
self.assertTrue(np.array_equal(new_imp.intensity, np.array([4., 24., 34., 44.,
54., 64., 74., 84., 104.])))
self.assertTrue(np.allclose(new_imp.mdd, np.array([0, 0, 0, 0.025000000000000,
0.054054054054054, 0.104615384615385, 0.211764705882353, 0.400000000000000, 0.400000000000000])))
self.assertTrue(np.allclose(new_imp.paa, np.array([0, 0.004000000000000, 0, 0.160000000000000,
0.370000000000000, 0.650000000000000, 0.850000000000000, 1.000000000000000,
1.000000000000000])))
def test_calc_impact_measures_pass(self):
"""Test _calc_impact_measures against reference value"""
self.assertTrue(HAZ_TEST_MAT.is_file(),
"{} is not a file".format(HAZ_TEST_MAT))
hazard = Hazard('TC')
hazard.read_mat(HAZ_TEST_MAT)
self.assertTrue(ENT_TEST_MAT.is_file(),
"{} is not a file".format(ENT_TEST_MAT))
entity = Entity()
entity.read_mat(ENT_TEST_MAT)
entity.check()
entity.measures._data['TC'] = entity.measures._data.pop('XX')
for meas in entity.measures.get_measure('TC'):
meas.haz_type = 'TC'
entity.check()
cost_ben = CostBenefit()
cost_ben._calc_impact_measures(hazard,
entity.exposures,
entity.measures,
entity.impact_funcs,
when='future',
risk_func=risk_aai_agg,
save_imp=True)
self.assertEqual(cost_ben.imp_meas_present, dict())
self.assertEqual(cost_ben.cost_ben_ratio, dict())
self.assertEqual(cost_ben.benefit, dict())
self.assertEqual(cost_ben.tot_climate_risk, 0.0)
self.assertEqual(cost_ben.present_year, 2016)
self.assertEqual(cost_ben.future_year, 2030)
self.assertEqual(cost_ben.imp_meas_future['no measure']['cost'],
(0, 0))
self.assertAlmostEqual(cost_ben.imp_meas_future['no measure']['risk'],
6.51220115756442e+09,
places=3)
new_efc = cost_ben.imp_meas_future['no measure'][
'impact'].calc_freq_curve()
self.assertTrue(
np.allclose(
new_efc.return_per,
cost_ben.imp_meas_future['no measure']['efc'].return_per))
self.assertTrue(
np.allclose(new_efc.impact,
cost_ben.imp_meas_future['no measure']['efc'].impact))
self.assertEqual(
cost_ben.imp_meas_future['no measure']
['impact'].at_event.nonzero()[0].size, 841)
self.assertAlmostEqual(
cost_ben.imp_meas_future['no measure']['impact'].at_event[14082],
8.801682862431524e+06,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['no measure']['impact'].tot_value,
6.570532945599105e+11,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['no measure']['impact'].aai_agg,
6.51220115756442e+09,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Mangroves']['cost'][0],
1.3117683608515418e+09,
places=3)
self.assertEqual(cost_ben.imp_meas_future['Mangroves']['cost'][1], 1)
self.assertAlmostEqual(cost_ben.imp_meas_future['Mangroves']['risk'],
4.850407096284983e+09,
places=3)
new_efc = cost_ben.imp_meas_future['Mangroves'][
'impact'].calc_freq_curve()
self.assertTrue(
np.allclose(
new_efc.return_per,
cost_ben.imp_meas_future['Mangroves']['efc'].return_per))
self.assertTrue(
np.allclose(new_efc.impact,
cost_ben.imp_meas_future['Mangroves']['efc'].impact))
self.assertEqual(
cost_ben.imp_meas_future['Mangroves']['impact'].at_event.nonzero()
[0].size, 665)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Mangroves']['impact'].at_event[13901],
1.29576562770977e+09,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Mangroves']['impact'].tot_value,
6.570532945599105e+11,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Mangroves']['impact'].aai_agg,
4.850407096284983e+09,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Beach nourishment']['cost'][0],
1.728000000000000e+09,
places=3)
self.assertEqual(
cost_ben.imp_meas_future['Beach nourishment']['cost'][1], 1)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Beach nourishment']['risk'],
5.188921355413834e+09,
places=3)
new_efc = cost_ben.imp_meas_future['Beach nourishment'][
'impact'].calc_freq_curve()
self.assertTrue(
np.allclose(
new_efc.return_per,
cost_ben.imp_meas_future['Beach nourishment']
['efc'].return_per))
self.assertTrue(
np.allclose(
new_efc.impact,
cost_ben.imp_meas_future['Beach nourishment']['efc'].impact))
self.assertEqual(
cost_ben.imp_meas_future['Beach nourishment']
['impact'].at_event.nonzero()[0].size, 702)
self.assertEqual(
cost_ben.imp_meas_future['Beach nourishment']
['impact'].at_event[1110], 0.0)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Beach nourishment']['impact'].eai_exp[5],
1.1133679079730146e+08,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Beach nourishment']['impact'].tot_value,
6.570532945599105e+11,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Beach nourishment']['impact'].aai_agg,
5.188921355413834e+09,
places=3)
self.assertAlmostEqual(cost_ben.imp_meas_future['Seawall']['cost'][0],
8.878779433630093e+09,
places=3)
self.assertEqual(cost_ben.imp_meas_future['Seawall']['cost'][1], 1)
self.assertAlmostEqual(cost_ben.imp_meas_future['Seawall']['risk'],
4.736400526119911e+09,
places=3)
new_efc = cost_ben.imp_meas_future['Seawall'][
'impact'].calc_freq_curve()
self.assertTrue(
np.allclose(new_efc.return_per,
cost_ben.imp_meas_future['Seawall']['efc'].return_per))
self.assertTrue(
np.allclose(new_efc.impact,
cost_ben.imp_meas_future['Seawall']['efc'].impact))
self.assertEqual(
cost_ben.imp_meas_future['Seawall']['impact'].at_event.nonzero()
[0].size, 73)
self.assertEqual(
cost_ben.imp_meas_future['Seawall']['impact'].at_event[1229], 0.0)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Seawall']['impact'].tot_value,
6.570532945599105e+11,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Seawall']['impact'].aai_agg,
4.736400526119911e+09,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Building code']['cost'][0],
9.200000000000000e+09,
places=3)
self.assertEqual(cost_ben.imp_meas_future['Building code']['cost'][1],
1)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Building code']['risk'],
4.884150868173321e+09,
places=3)
new_efc = cost_ben.imp_meas_future['Building code'][
'impact'].calc_freq_curve()
self.assertTrue(
np.allclose(
new_efc.return_per,
cost_ben.imp_meas_future['Building code']['efc'].return_per))
self.assertTrue(
np.allclose(
new_efc.impact,
cost_ben.imp_meas_future['Building code']['efc'].impact))
self.assertEqual(
cost_ben.imp_meas_future['Building code']
['impact'].at_event.nonzero()[0].size, 841)
self.assertEqual(
cost_ben.imp_meas_future['Building code']['impact'].at_event[122],
0.0)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Building code']['impact'].eai_exp[11],
7.757060129393841e+07,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Building code']['impact'].tot_value,
6.570532945599105e+11,
places=3)
self.assertAlmostEqual(
cost_ben.imp_meas_future['Building code']['impact'].aai_agg,
4.884150868173321e+09,
places=3)
