def emdat_impact_event(countries, hazard_name, emdat_file_csv, year_range, \
reference_year=0, imp_str="Total damage ('000 US$)"):
"""function to load EM-DAT data return impact per event
Parameters:
countries (list of str): country ISO3-codes or names, i.e. ['JAM'].
hazard_name (str): Hazard name according to EMDAT terminology or
CLIMADA abbreviation, i.e. 'TC'
emdat_file_csv (str): Full path to EMDAT-file (CSV), i.e.:
emdat_file_csv = os.path.join(SYSTEM_DIR, 'emdat_201810.csv')
reference_year (int): reference year of exposures. Impact is scaled
proportional to GDP to the value of the reference year. No scaling
for 0 (default)
imp_str (str): Column name of impact metric in EMDAT CSV,
default = "Total damage ('000 US$)"
Returns:
out (pandas DataFrame): EMDAT DataFrame with new columns "year",
"region_id", and scaled total impact per event with
same unit as chosen impact,
i.e. 1000 current US$ for imp_str="Total damage ('000 US$) scaled".
"""
out = pd.DataFrame()
for country in countries:
data, _, country = emdat_df_load(country, hazard_name, \
emdat_file_csv, year_range)
if data is None:
continue
if reference_year > 0:
gdp_ref = gdp(country, reference_year)[1]
else:
gdp_ref = 0
data['year'] = pd.Series(np.zeros(data.shape[0], dtype='int'), \
index=data.index)
data['region_id'] = pd.Series(int(iso_cntry.get(country).numeric) + \
np.zeros(data.shape[0], dtype='int'), \
index=data.index)
data['reference_year'] = pd.Series(reference_year+np.zeros(\
data.shape[0], dtype='int'), index=data.index)
data[imp_str + " scaled"] = pd.Series(np.zeros(data.shape[0], dtype='int'), \
index=data.index)
for cnt in np.arange(data.shape[0]):
data.loc[cnt, 'year'] = int(data.loc[cnt, 'Disaster No.'][0:4])
data.loc[cnt, 'reference_year'] = int(reference_year)
if data.loc[cnt][imp_str] > 0 and gdp_ref > 0:
data.loc[cnt, imp_str + " scaled"] = \
data.loc[cnt, imp_str] * gdp_ref / \
gdp(country, int(data.loc[cnt, 'year']))[1]
out = out.append(data)
del data
out = out.reset_index(drop=True)
if '000 US' in imp_str and not out.empty: # EM-DAT damages provided in '000 USD
out[imp_str + " scaled"] = out[imp_str + " scaled"] * 1e3
out[imp_str] = out[imp_str] * 1e3
return out
def emdat_impact_yearlysum(countries, hazard_name, emdat_file_csv, year_range=None, \
reference_year=0, imp_str="Total damage ('000 US$)"):
"""function to load EM-DAT data and sum impact per year
Parameters:
countries (list of str): country ISO3-codes or names, i.e. ['JAM'].
hazard_name (str): Hazard name according to EMDAT terminology or
CLIMADA abbreviation
emdat_file_csv (str): Full path to EMDAT-file (CSV), i.e.:
emdat_file_csv = os.path.join(SYSTEM_DIR, 'emdat_201810.csv')
reference_year (int): reference year of exposures. Impact is scaled
proportional to GDP to the value of the reference year. No scaling
for 0 (default)
imp_str (str): Column name of impact metric in EMDAT CSV,
default = "Total damage ('000 US$)"
Returns:
yearly_impact (dict, mapping years to impact):
total impact per year, same unit as chosen impact,
i.e. 1000 current US$ for imp_str="Total damage ('000 US$)".
all_years (list of int): list of years
"""
out = pd.DataFrame()
for country in countries:
data, all_years, country = emdat_df_load(country, hazard_name, \
emdat_file_csv, year_range)
if data is None:
continue
data_out = pd.DataFrame(index=np.arange(0, len(all_years)), \
columns=['ISO3', 'region_id', 'year', 'impact', \
'reference_year', 'impact_scaled'])
if reference_year > 0:
gdp_ref = gdp(country, reference_year)[1]
for cnt, year in enumerate(all_years):
data_out.loc[cnt, 'year'] = year
data_out.loc[cnt, 'reference_year'] = reference_year
data_out.loc[cnt, 'ISO3'] = country
data_out.loc[cnt,
'region_id'] = int(iso_cntry.get(country).numeric)
data_out.loc[cnt, 'impact'] = \
sum(data.loc[data['Disaster No.'].str.contains(str(year))]\
[imp_str])
if '000 US' in imp_str: # EM-DAT damages provided in '000 USD
data_out.loc[cnt,
'impact'] = data_out.loc[cnt, 'impact'] * 1000
if reference_year > 0:
data_out.loc[cnt, 'impact_scaled'] = data_out.loc[cnt, 'impact'] * \
gdp_ref / gdp(country, year)[1]
out = out.append(data_out)
out = out.reset_index(drop=True)
return out
def test_switzerland300_pass(self):
"""Create LitPop entity for Switzerland on 300 arcsec:"""
country_name = ['CHE']
resolution = 300
fin_mode = 'income_group'
with self.assertLogs('climada.entity.exposures.litpop',
level='INFO') as cm:
ent = lp.LitPop.from_countries(country_name,
res_arcsec=resolution,
fin_mode=fin_mode,
reference_year=2016)
self.assertIn('LitPop: Init Exposure for country: CHE', cm.output[0])
self.assertEqual(ent.gdf.region_id.min(), 756)
self.assertEqual(ent.gdf.region_id.max(), 756)
# confirm that the total value is equal to GDP * (income_group+1):
self.assertAlmostEqual(ent.gdf.value.sum() / gdp('CHE', 2016)[1],
(income_group('CHE', 2016)[1] + 1))
self.assertIn("LitPop Exposure for ['CHE'] at 300 as, year: 2016",
ent.tag.description)
self.assertIn('income_group', ent.tag.description)
self.assertIn('1, 1', ent.tag.description)
self.assertTrue(u_coord.equal_crs(ent.crs, 'epsg:4326'))
self.assertEqual(ent.meta['width'], 54)
self.assertEqual(ent.meta['height'], 23)
self.assertTrue(u_coord.equal_crs(ent.meta['crs'], 'epsg:4326'))
self.assertAlmostEqual(ent.meta['transform'][0], 0.08333333333333333)
self.assertAlmostEqual(ent.meta['transform'][1], 0)
self.assertAlmostEqual(ent.meta['transform'][2], 5.9166666666666)
self.assertAlmostEqual(ent.meta['transform'][3], 0)
self.assertAlmostEqual(ent.meta['transform'][4], -0.08333333333333333)
self.assertAlmostEqual(ent.meta['transform'][5], 47.75)
def fill_econ_indicators(ref_year, cntry_info, shp_file, **kwargs):
"""Get GDP and income group per country in reference year, or it closest
one. Source: world bank. Natural earth repository used when missing data.
Modifies country info with values [country id, country name,
country geometry, ref_year, gdp, income_group].
Parameters:
ref_year (int): reference year
cntry_info (dict): key = ISO alpha_3 country, value = [country id,
country name, country geometry]
kwargs (optional): 'gdp' and 'inc_grp' dictionaries with keys the
country ISO_alpha3 code. If provided, these are used
"""
for cntry_iso, cntry_val in cntry_info.items():
cntry_val.append(ref_year)
if 'gdp' in kwargs and kwargs['gdp'][cntry_iso] != '':
gdp_val = kwargs['gdp'][cntry_iso]
else:
_, gdp_val = gdp(cntry_iso, ref_year, shp_file)
cntry_val.append(gdp_val)
if 'inc_grp' in kwargs and kwargs['inc_grp'][cntry_iso] != '':
inc_grp = kwargs['inc_grp'][cntry_iso]
else:
_, inc_grp = income_group(cntry_iso, ref_year, shp_file)
cntry_val.append(inc_grp)
def scale_impact2refyear(impact_values,
year_values,
iso3a_values,
reference_year=None):
"""Scale give impact values proportional to GDP to the according value in a reference year
(for normalization of monetary values)
Parameters
----------
impact_values : list or array
Impact values to be scaled.
year_values : list or array
Year of each impact (same length as impact_values)
iso3a_values : list or array
ISO3alpha code of country for each impact (same length as impact_values)
Optional Parameters
-------------------
reference_year : int
Impact is scaled proportional to GDP to the value of the reference year.
No scaling for reference_year=None (default)
"""
impact_values = np.array(impact_values)
year_values = np.array(year_values)
iso3a_values = np.array(iso3a_values)
if reference_year and isinstance(reference_year, (int, float)):
reference_year = int(reference_year)
gdp_ref = dict()
gdp_years = dict()
for country in np.unique(iso3a_values):
# get reference GDP value for each country:
gdp_ref[country] = gdp(country, reference_year)[1]
# get GDP value for each country and year:
gdp_years[country] = dict()
years_country = np.unique(year_values[iso3a_values == country])
print(years_country)
for year in years_country:
gdp_years[country][year] = gdp(country, year)[1]
# loop through each value and apply scaling:
for idx, val in enumerate(impact_values):
impact_values[idx] = val * gdp_ref[iso3a_values[idx]] / \
gdp_years[iso3a_values[idx]][year_values[idx]]
return list(impact_values)
if not reference_year:
return impact_values
raise ValueError('Invalid reference_year')
def test_gdp_twn_2012_pass(self):
"""Test gdp function TWN."""
ref_year = 2014
res_year, res_val = gdp('TWN', ref_year)
_, res_val_direct = _gdp_twn(ref_year)
ref_val = 530515000000.0
ref_year = 2014
self.assertEqual(res_year, ref_year)
self.assertEqual(res_val, ref_val)
self.assertEqual(res_val_direct, ref_val)
def test_gdp_sxm_2012_pass(self):
""" Test gdp function Sint Maarten."""
ref_year = 2012
with self.assertLogs('climada.util.finance', level='INFO') as cm:
res_year, res_val = gdp('SXM', ref_year)
ref_val = 3.658e+08
ref_year = 2014
self.assertIn('GDP SXM 2014: 3.658e+08', cm.output[0])
self.assertEqual(res_year, ref_year)
self.assertEqual(res_val, ref_val)
def test_gdp_sxm_2010_pass(self):
"""Test gdp function Sint Maarten."""
# If World Bank input data changes, make sure to set ref_year to a year where
# no data is available so that the next available data point has to be selected.
ref_year = 2010
with self.assertLogs('climada.util.finance', level='INFO') as cm:
res_year, res_val = gdp('SXM', ref_year)
ref_val = 936089385.47486 # reference GDP value
ref_year = 2011 # nearest year with data available (might change)
# GDP and years with data available might change if worldbank input
# data changes, check magnitude and adjust ref_val and/or ref_year
# if test fails:
self.assertIn('GDP SXM %i: %1.3e' % (ref_year, ref_val), cm.output[0])
self.assertEqual(res_year, ref_year)
self.assertAlmostEqual(res_val, ref_val, places=0)
