def _init_centroids(dis_xarray, centr_res_factor=1):
"""Get centroids from the firms dataset and refactor them.
Parameters:
dis_xarray (xarray): dataset obtained from ISIMIP netcdf
Optional Parameters:
centr_res_factor (float): the factor applied to voluntarly decrease/increase
the centroids resolution
Returns:
centroids (Centroids)
"""
res_data = np.min(
np.abs([
np.diff(dis_xarray.lon.values).min(),
np.diff(dis_xarray.lat.values).min()
]))
centroids = Centroids()
centroids.set_raster_from_pnt_bounds(
(dis_xarray.lon.values.min(), dis_xarray.lat.values.min(),
dis_xarray.lon.values.max(), dis_xarray.lat.values.max()),
res=res_data / centr_res_factor)
centroids.set_meta_to_lat_lon()
centroids.set_area_approx()
centroids.set_on_land()
centroids.empty_geometry_points()
return centroids
def _select_exact_area(countries=[], reg=[]):
"""Extract coordinates of selected countries or region
from NatID grid. If countries are given countries are cut,
if only reg is given, the whole region is cut.
Parameters:
countries: List of countries
reg: List of regions
Raises:
KeyError
Returns:
centroids
"""
lat, lon = get_region_gridpoints(countries=countries,
regions=reg,
basemap="isimip",
resolution=150)
if reg:
country_isos = region2isos(reg)
else:
country_isos = countries
natIDs = country_iso2natid(country_isos)
centroids = Centroids()
centroids.set_lat_lon(lat, lon)
centroids.id = np.arange(centroids.lon.shape[0])
# centroids.set_region_id()
return centroids, country_isos, natIDs
def test_meta_centroids_flood(self):
min_lat, max_lat, min_lon, max_lon = 45.7, 47.8, 7.5, 10.5
cent = Centroids()
cent.set_raster_from_pnt_bounds((min_lon, min_lat, max_lon, max_lat),
res=0.05)
rf_rast = RiverFlood()
rf_rast.set_from_nc(dph_path=HAZ_DEMO_FLDDPH,
frc_path=HAZ_DEMO_FLDFRC,
centroids=cent)
self.assertEqual(rf_rast.centroids.shape, (43, 61))
self.assertAlmostEqual(np.min(rf_rast.centroids.lat),
45.70000000000012, 4)
self.assertAlmostEqual(np.max(rf_rast.centroids.lat), 47.8, 4)
self.assertAlmostEqual(np.min(rf_rast.centroids.lon), 7.5, 4)
self.assertAlmostEqual(np.max(rf_rast.centroids.lon),
10.49999999999999, 4)
self.assertAlmostEqual(rf_rast.centroids.lon[90], 8.949999999999996, 4)
self.assertAlmostEqual(rf_rast.centroids.lat[90], 47.75, 4)
self.assertEqual(rf_rast.intensity.shape, (1, 2623))
self.assertAlmostEqual(np.min(rf_rast.intensity), 0.0, 4)
self.assertAlmostEqual(np.max(rf_rast.intensity), 5.8037286, 4)
self.assertEqual(np.argmin(rf_rast.intensity), 0, 4)
self.assertEqual(np.argmax(rf_rast.intensity), 55, 4)
self.assertEqual(rf_rast.fraction.shape, (1, 2623))
self.assertAlmostEqual(np.min(rf_rast.fraction), 0.0, 4)
self.assertAlmostEqual(np.max(rf_rast.fraction), 0.4896, 4)
self.assertEqual(np.argmin(rf_rast.fraction), 0, 4)
self.assertEqual(np.argmax(rf_rast.fraction), 360, 4)
def init_test_centroids(data):
"""define centroids for test data:"""
centroids = Centroids()
grid = np.meshgrid(np.arange(data.lat.min(), data.lat.max()+.5, .5),
np.arange(data.lon.min(), data.lon.max()+.5, .5))
lat = list()
lon = list()
for arrlat, arrlon in zip(list(grid[0]), list(grid[1])):
lat += list(arrlat)
lon += list(arrlon)
centroids.set_lat_lon(np.array(lat), np.array(lon))
centroids.set_lat_lon_to_meta()
return centroids
def select_exact_area(countries=[], reg=[]):
""" Extract coordinates of selected countries or region
from NatID grid. If countries are given countries are cut,
if only reg is given, the whole region is cut.
Parameters:
countries: List of countries
reg: List of regions
Raises:
KeyError
Returns:
centroids
"""
centroids = Centroids()
natID_info = pd.read_csv(NAT_REG_ID)
isimip_grid = xr.open_dataset(GLB_CENTROIDS_NC)
isimip_lon = isimip_grid.lon.data
isimip_lat = isimip_grid.lat.data
gridX, gridY = np.meshgrid(isimip_lon, isimip_lat)
try:
if countries:
if not any(np.isin(natID_info['ISO'], countries)):
LOGGER.error('Country ISO3s ' + str(countries) +
' unknown')
raise KeyError
natID = natID_info["ID"][np.isin(natID_info["ISO"], countries)]
elif reg:
if not any(np.isin(natID_info["Reg_name"], reg)):
LOGGER.error('Shortcuts ' + str(reg) + ' unknown')
raise KeyError
natID = natID_info["ID"][np.isin(natID_info["Reg_name"], reg)]
else:
centroids.lon = np.zeros((gridX.size))
centroids.lat = np.zeros((gridX.size))
centroids.lon = gridX.flatten()
centroids.lat = gridY.flatten()
centroids.id = np.arange(centroids.lon.shape[0])
return centroids
except KeyError:
LOGGER.error('Selected country or region do ' +
'not match reference file')
raise KeyError
isimip_NatIdGrid = isimip_grid.NatIdGrid.data
natID_pos = np.isin(isimip_NatIdGrid, natID)
lon_coordinates = gridX[natID_pos]
lat_coordinates = gridY[natID_pos]
centroids.set_lat_lon(lat_coordinates, lon_coordinates)
centroids.id = np.arange(centroids.lon.shape[0])
centroids.set_region_id()
return centroids
def select_exact_area_polygon(countries=[], reg=[]):
""" Extract coordinates of selected countries or region
from NatID grid. If countries are given countries are cut,
if only reg is given, the whole region is cut.
Parameters:
countries: List of countries
reg: List of regions
Raises:
AttributeError
Returns:
np.array
"""
centroids = Centroids()
natID_info = pd.read_csv(NAT_REG_ID)
isimip_grid = xr.open_dataset(GLB_CENTROIDS_NC)
isimip_lon = isimip_grid.lon.data
isimip_lat = isimip_grid.lat.data
gridX, gridY = np.meshgrid(isimip_lon, isimip_lat)
if countries:
natID = natID_info["ID"][np.isin(natID_info["ISO"], countries)]
elif reg:
natID = natID_info["ID"][np.isin(natID_info["Reg_name"], reg)]
else:
centroids.coord = np.zeros((gridX.size, 2))
centroids.coord[:, 1] = gridX.flatten()
centroids.coord[:, 0] = gridY.flatten()
centroids.id = np.arange(centroids.coord.shape[0])
return centroids
isimip_NatIdGrid = isimip_grid.NatIdGrid.data
natID_pos = np.isin(isimip_NatIdGrid, natID)
lon_coordinates = gridX[natID_pos]
lat_coordinates = gridY[natID_pos]
centroids.coord = np.zeros((len(lon_coordinates), 2))
centroids.coord[:, 1] = lon_coordinates
centroids.coord[:, 0] = lat_coordinates
centroids.id = np.arange(centroids.coord.shape[0])
orig_proj = 'epsg:4326'
country = gpd.GeoDataFrame()
country['geometry'] = list(
zip(centroids.coord[:, 1], centroids.coord[:, 0]))
country['geometry'] = country['geometry'].apply(Point)
country.crs = {'init': orig_proj}
points = country.geometry.values
concave_hull, _ = alpha_shape(points, alpha=1)
return concave_hull
def test_centroids_flood(self):
# this is going to go through the meta part
rand_centroids = Centroids()
lat = np.arange(47, 56, 0.2)
lon = np.arange(5, 15, 0.2)
lon, lat = np.meshgrid(lon, lat)
rand_centroids.set_lat_lon(lat.flatten(), lon.flatten())
rf = RiverFlood()
rf.set_from_nc(dph_path=HAZ_DEMO_FLDDPH,
frc_path=HAZ_DEMO_FLDFRC,
centroids=rand_centroids,
ISINatIDGrid=False)
self.assertEqual(rf.date[0], 730303)
self.assertEqual(rf.event_id[0], 0)
self.assertEqual(rf.event_name[0], '2000')
self.assertEqual(rf.orig[0], False)
self.assertAlmostEqual(rf.frequency[0], 1.)
self.assertEqual(rf.centroids.shape, (45, 50))
self.assertAlmostEqual(np.min(rf.centroids.lat), 47.0, 4)
self.assertAlmostEqual(np.max(rf.centroids.lat), 55.8, 4)
self.assertAlmostEqual(np.min(rf.centroids.lon), 5.0, 4)
self.assertAlmostEqual(np.max(rf.centroids.lon), 14.8, 4)
self.assertAlmostEqual(rf.centroids.lon[90], 13.0, 4)
self.assertAlmostEqual(rf.centroids.lat[90], 47.2, 4)
self.assertEqual(rf.intensity.shape, (1, 2250))
self.assertAlmostEqual(np.min(rf.intensity), 0.0, 4)
self.assertAlmostEqual(np.max(rf.intensity), 8.921593, 4)
self.assertEqual(np.argmin(rf.intensity), 0, 4)
self.assertEqual(np.argmax(rf.intensity), 191, 4)
self.assertEqual(rf.fraction.shape, (1, 2250))
self.assertAlmostEqual(np.min(rf.fraction), 0.0, 4)
self.assertAlmostEqual(np.max(rf.fraction), 0.92, 4)
self.assertEqual(np.argmin(rf.fraction), 0, 4)
self.assertEqual(np.argmax(rf.fraction), 1438, 4)
Test tc_surge module.
"""
import os
import copy
import unittest
import numpy as np
from climada.hazard import TCSurge, TropCyclone, TCTracks
from climada.hazard.centroids import Centroids
DATA_DIR = os.path.join(os.path.dirname(__file__), os.pardir,
'hazard/test/data')
TEST_TRACK = os.path.join(DATA_DIR, "trac_brb_test.csv")
CENTR_TEST_BRB = Centroids()
CENTR_TEST_BRB.read_mat(os.path.join(DATA_DIR, 'centr_brb_test.mat'))
class TestEnd2End(unittest.TestCase):
"""Test reading TC from IBTrACS files"""
def test_track_to_surge_point_pass(self):
""" Test set_from_winds with default points (same as as_pixel=False) """
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.calc_random_walk()
tc_track.equal_timestep()
tc_haz = TropCyclone()
tc_haz.set_from_tracks(tc_track, CENTR_TEST_BRB)
def select_window_area(countries=[], reg=[]):
""" Extract coordinates of selected countries or region
from NatID in a rectangular box. If countries are given countries
are cut, if only reg is given, the whole region is cut.
Parameters:
countries: List of countries
reg: List of regions
Raises:
AttributeError
Returns:
np.array
"""
centroids = Centroids()
natID_info = pd.read_csv(NAT_REG_ID)
isimip_grid = xr.open_dataset(GLB_CENTROIDS_NC)
isimip_lon = isimip_grid.lon.data
isimip_lat = isimip_grid.lat.data
gridX, gridY = np.meshgrid(isimip_lon, isimip_lat)
if countries:
if not any(np.isin(natID_info['ISO'], countries)):
LOGGER.error('Country ISO3s ' + str(countries) + ' unknown')
raise KeyError
natID = natID_info["ID"][np.isin(natID_info["ISO"], countries)]
elif reg:
natID = natID_info["ID"][np.isin(natID_info["Reg_name"], reg)]
if not any(np.isin(natID_info["Reg_name"], reg)):
LOGGER.error('Shortcuts ' + str(reg) + ' unknown')
raise KeyError
else:
centroids.lat = np.zeros((gridX.size))
centroids.lon = np.zeros((gridX.size))
centroids.lon = gridX.flatten()
centroids.lat = gridY.flatten()
centroids.id = np.arange(centroids.lon.shape[0])
centroids.id = np.arange(centroids.lon.shape[0])
return centroids
isimip_NatIdGrid = isimip_grid.NatIdGrid.data
natID_pos = np.isin(isimip_NatIdGrid, natID)
lon_coordinates = gridX[natID_pos]
lat_coordinates = gridY[natID_pos]
lon_min = math.floor(min(lon_coordinates))
if lon_min <= -179:
lon_inmin = 0
else:
lon_inmin = min(np.where((isimip_lon >= lon_min))[0]) - 1
lon_max = math.ceil(max(lon_coordinates))
if lon_max >= 179:
lon_inmax = len(isimip_lon) - 1
else:
lon_inmax = max(np.where((isimip_lon <= lon_max))[0]) + 1
lat_min = math.floor(min(lat_coordinates))
if lat_min <= -89:
lat_inmin = 0
else:
lat_inmin = min(np.where((isimip_lat >= lat_min))[0]) - 1
lat_max = math.ceil(max(lat_coordinates))
if lat_max >= 89:
lat_max = len(isimip_lat) - 1
else:
lat_inmax = max(np.where((isimip_lat <= lat_max))[0]) + 1
lon = isimip_lon[lon_inmin:lon_inmax]
lat = isimip_lat[lat_inmin:lat_inmax]
gridX, gridY = np.meshgrid(lon, lat)
lat = np.zeros((gridX.size))
lon = np.zeros((gridX.size))
lon = gridX.flatten()
lat = gridY.flatten()
centroids.set_lat_lon(lat, lon)
centroids.id = np.arange(centroids.coord.shape[0])
centroids.set_region_id()
return centroids
def _set_centroids_from_file(self, lon, lat):
self.centroids = Centroids()
gridX, gridY = np.meshgrid(lon, lat)
self.centroids.set_lat_lon(gridY.flatten(), gridX.flatten())