def test_ibtracs_correct_pass(self):
""" Check correct_pres option """
tc_try = TCTracks()
tc_try.read_ibtracs_netcdf(provider='usa', storm_id='1982267N25289', correct_pres=True)
self.assertAlmostEqual(tc_try.data[0].central_pressure.values[0], 1011.2905126953125)
self.assertAlmostEqual(tc_try.data[0].central_pressure.values[5], 1005.706236328125)
self.assertAlmostEqual(tc_try.data[0].central_pressure.values[-1], 1011.6555029296875)
def test_decay_values_andrew_pass(self):
""" Test _decay_values with central pressure function."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TC_ANDREW_FL)
s_rel = False
land_geom = tc._calc_land_geom(tc_track.data)
tc._track_land_params(tc_track.data[0], land_geom)
v_lf, p_lf, x_val = tc._decay_values(tc_track.data[0], land_geom, s_rel)
ss_category = 6
s_cell_1 = 1*[1.0149413347244263]
s_cell_2 = 8*[1.047120451927185]
s_cell = s_cell_1 + s_cell_2
p_vs_lf_time_relative = [1.0149413020277482, 1.018848167539267, 1.037696335078534, \
1.0418848167539267, 1.043979057591623, 1.0450261780104713, \
1.0460732984293193, 1.0471204188481675, 1.0471204188481675]
self.assertEqual(list(p_lf.keys()), [ss_category])
self.assertEqual(p_lf[ss_category][0], array.array('f', s_cell))
self.assertEqual(p_lf[ss_category][1], array.array('f', p_vs_lf_time_relative))
v_vs_lf_time_relative = [0.8846153846153846, 0.6666666666666666, 0.4166666666666667, \
0.2916666666666667, 0.250000000000000, 0.250000000000000, \
0.20833333333333334, 0.16666666666666666, 0.16666666666666666]
self.assertEqual(list(v_lf.keys()), [ss_category])
self.assertEqual(v_lf[ss_category], array.array('f', v_vs_lf_time_relative))
x_val_ref = np.array([95.9512939453125, 53.624916076660156, 143.09530639648438,
225.0262908935547, 312.5832824707031, 427.43109130859375,
570.1857299804688, 750.3827514648438, 1020.5431518554688])
self.assertEqual(list(x_val.keys()), [ss_category])
self.assertTrue(np.allclose(x_val[ss_category], x_val_ref))
def test_read_pass(self):
"""Read a tropical cyclone."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
self.assertEqual(tc_track.data[0].time.size, 38)
self.assertEqual(tc_track.data[0].lon[11], -39.60)
self.assertEqual(tc_track.data[0].lat[23], 14.10)
self.assertEqual(tc_track.data[0].time_step[7], 6)
self.assertEqual(np.max(tc_track.data[0].radius_max_wind), 0)
self.assertEqual(np.min(tc_track.data[0].radius_max_wind), 0)
self.assertEqual(tc_track.data[0].max_sustained_wind[21], 55)
self.assertEqual(tc_track.data[0].central_pressure[29], 969.76880)
self.assertEqual(np.max(tc_track.data[0].environmental_pressure), 1010)
self.assertEqual(np.min(tc_track.data[0].environmental_pressure), 1010)
self.assertEqual(tc_track.data[0].time.dt.year[13], 1951)
self.assertEqual(tc_track.data[0].time.dt.month[26], 9)
self.assertEqual(tc_track.data[0].time.dt.day[7], 29)
self.assertEqual(tc_track.data[0].max_sustained_wind_unit, 'kn')
self.assertEqual(tc_track.data[0].central_pressure_unit, 'mb')
self.assertEqual(tc_track.data[0].orig_event_flag, 1)
self.assertEqual(tc_track.data[0].name, '1951239N12334')
self.assertEqual(tc_track.data[0].sid, '1951239N12334')
self.assertEqual(tc_track.data[0].id_no, 1951239012334)
self.assertEqual(tc_track.data[0].data_provider, 'hurdat_atl')
self.assertTrue(np.isnan(tc_track.data[0].basin))
self.assertEqual(tc_track.data[0].id_no, 1951239012334)
self.assertEqual(tc_track.data[0].category, 1)
def test_two_files_pass(self):
"""Test set function set_from_tracks with two ibtracs."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(
[TEST_TRACK_SHORT, TEST_TRACK_SHORT])
tc_haz = TCRain()
tc_haz.set_from_tracks(tc_track, CENTR_TEST_BRB)
tc_haz.remove_duplicates()
tc_haz.check()
self.assertEqual(tc_haz.tag.haz_type, 'TR')
self.assertEqual(tc_haz.tag.description, '')
self.assertEqual(tc_haz.tag.file_name,
['IBTrACS: 1951239N12334', 'IBTrACS: 1951239N12334'])
self.assertEqual(tc_haz.units, 'mm')
self.assertEqual(tc_haz.centroids.size, 296)
self.assertEqual(tc_haz.event_id.size, 1)
self.assertEqual(tc_haz.event_id[0], 1)
self.assertEqual(tc_haz.event_name, ['1951239N12334'])
self.assertTrue(np.array_equal(tc_haz.frequency, np.array([1])))
self.assertTrue(np.array_equal(tc_haz.orig, np.array([True])))
self.assertTrue(isinstance(tc_haz.intensity, sparse.csr.csr_matrix))
self.assertTrue(isinstance(tc_haz.fraction, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.intensity.shape, (1, 296))
self.assertEqual(tc_haz.fraction.shape, (1, 296))
self.assertEqual(tc_haz.fraction.nonzero()[0].size, 0)
self.assertEqual(tc_haz.intensity.nonzero()[0].size, 0)
def test_set_one_file_pass(self):
"""Test set function set_from_tracks with one input."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK_SHORT)
tc_haz = TCRain()
tc_haz.set_from_tracks(tc_track, CENTR_TEST_BRB)
tc_haz.check()
self.assertEqual(tc_haz.tag.haz_type, 'TR')
self.assertEqual(tc_haz.tag.description, '')
self.assertEqual(tc_haz.tag.file_name, 'IBTrACS: 1951239N12334')
self.assertEqual(tc_haz.units, 'mm')
self.assertEqual(tc_haz.centroids.size, 296)
self.assertEqual(tc_haz.event_id.size, 1)
self.assertEqual(tc_haz.event_id[0], 1)
self.assertEqual(tc_haz.event_name, ['1951239N12334'])
self.assertEqual(tc_haz.category, tc_track.data[0].category)
self.assertEqual(tc_haz.basin[0], "NA")
self.assertIsInstance(tc_haz.basin, list)
self.assertIsInstance(tc_haz.category, np.ndarray)
self.assertTrue(np.array_equal(tc_haz.frequency, np.array([1])))
self.assertTrue(isinstance(tc_haz.intensity, sparse.csr.csr_matrix))
self.assertTrue(isinstance(tc_haz.fraction, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.intensity.shape, (1, 296))
self.assertEqual(tc_haz.fraction.shape, (1, 296))
self.assertEqual(tc_haz.fraction.nonzero()[0].size, 0)
self.assertEqual(tc_haz.intensity.nonzero()[0].size, 0)
def test_filter_ibtracs_track_pass(self):
""" Test _filter_ibtracs """
fn_nc = os.path.join(os.path.abspath(SYSTEM_DIR), 'IBTrACS.ALL.v04r00.nc')
storm_id='1988234N13299'
tc_track = TCTracks()
sel = tc_track._filter_ibtracs(fn_nc, storm_id, year_range=None, basin=None)
self.assertTrue(sel, np.array([10000]))
def test_calc_orig_lf(self):
""" Test _calc_orig_lf for andrew tropical cyclone."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TC_ANDREW_FL)
track = tc_track.get_track()
track['on_land'] = ('time',
coord_on_land(track.lat.values, track.lon.values))
sea_land_idx = np.where(np.diff(track.on_land.astype(int)) == 1)[0]
orig_lf = tc._calc_orig_lf(track, sea_land_idx)
self.assertEqual(orig_lf.shape, (sea_land_idx.size, 2))
self.assertTrue(np.array_equal(orig_lf[0], np.array([25.5, -80.25])))
self.assertTrue(np.array_equal(orig_lf[1], np.array([29.65, -91.5])))
def test_set_one_file_pass(self):
""" Test set function set_from_tracks with one input."""
pool = Pool()
tc_track = TCTracks(pool)
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.calc_random_walk()
tc_track.equal_timestep()
tc_haz = TropCyclone(pool)
tc_haz.set_from_tracks(tc_track, CENTR_TEST_BRB)
tc_haz.check()
pool.close()
pool.join()
self.assertEqual(tc_haz.tag.haz_type, 'TC')
self.assertEqual(tc_haz.tag.description, '')
self.assertEqual(tc_haz.units, 'm/s')
self.assertEqual(tc_haz.centroids.size, 296)
self.assertEqual(tc_haz.event_id.size, 10)
self.assertTrue(isinstance(tc_haz.intensity, sparse.csr.csr_matrix))
self.assertTrue(isinstance(tc_haz.fraction, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.intensity.shape, (10, 296))
self.assertEqual(tc_haz.fraction.shape, (10, 296))
def test_read_and_tc_fail(self):
""" Append Hazard and Tropical Cyclone. Fail because of missing
category in hazard. """
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK_SHORT)
tc_haz1 = TropCyclone()
tc_haz1.read_mat(HAZ_TEST_MAT)
tc_haz2 = TropCyclone()
tc_haz2.set_from_tracks(tc_track, CENTR_TEST_BRB)
tc_haz2.append(tc_haz1)
self.assertEqual(tc_haz2.intensity.shape, (14451, 396))
with self.assertRaises(ValueError):
tc_haz2.check()
def test_vang_sym(self):
""" Test _vang_sym function. Compare to MATLAB reference. """
ureg = UnitRegistry()
i_node = 1
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
tc_track.data[0]['radius_max_wind'] = (
'time',
tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
tc_track.data[0].radius_max_wind.values,
ureg))
r_arr = np.array([
286.4938638337190, 290.5930935802884, 295.0271327746536,
299.7811253637995, 296.8484825705515, 274.9892882245964
])
v_trans = 5.2429431910897559
v_ang = tc._vang_sym(
tc_track.data[0].environmental_pressure.values[i_node],
tc_track.data[0].central_pressure.values[i_node - 1:i_node + 1],
tc_track.data[0].lat.values[i_node],
tc_track.data[0].time_step.values[i_node],
tc_track.data[0].radius_max_wind.values[i_node],
r_arr,
v_trans,
model=0)
to_kn = (1 * ureg.meter / ureg.second).to(ureg.knot).magnitude
self.assertEqual(v_ang.size, 6)
self.assertAlmostEqual(v_ang[0] * to_kn, 10.774196807905097)
self.assertAlmostEqual(v_ang[1] * to_kn, 10.591725180482094)
self.assertAlmostEqual(v_ang[2] * to_kn, 10.398212766600055)
self.assertAlmostEqual(v_ang[3] * to_kn, 10.195108683240084)
self.assertAlmostEqual(v_ang[4] * to_kn, 10.319869893291429)
self.assertAlmostEqual(v_ang[5] * to_kn, 11.305188714213809)
def test_windfield(self):
""" Test _windfield function. Compare to MATLAB reference. """
ureg = UnitRegistry()
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
tc_track.data[0]['radius_max_wind'] = (
'time',
tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
tc_track.data[0].radius_max_wind.values,
ureg))
coast_centr = tc.coastal_centr_idx(CENTR_TEST_BRB)
wind = tc._windfield(tc_track.data[0],
CENTR_TEST_BRB.coord,
coast_centr,
model=0)
to_kn = (1 * ureg.meter / ureg.second).to(ureg.knot).magnitude
self.assertEqual(wind.shape, (CENTR_TEST_BRB.size, ))
wind = wind[coast_centr]
self.assertEqual(np.nonzero(wind)[0].size, 280)
self.assertAlmostEqual(wind[0] * to_kn, 51.16153933277889)
self.assertAlmostEqual(wind[80] * to_kn, 64.15891933409763)
self.assertAlmostEqual(wind[120] * to_kn, 41.43819201370903)
self.assertAlmostEqual(wind[200] * to_kn, 57.28814245245439)
self.assertAlmostEqual(wind[220] * to_kn, 69.62477194818004)
def test_vtrans_correct(self):
""" Test _vtrans_correct function. Compare to MATLAB reference."""
ureg = UnitRegistry()
i_node = 1
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
tc_track.data[0]['radius_max_wind'] = (
'time',
tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
tc_track.data[0].radius_max_wind.values,
ureg))
r_arr = np.array([
286.4938638337190, 290.5930935802884, 295.0271327746536,
299.7811253637995, 296.8484825705515, 274.9892882245964
])
v_trans_corr = tc._vtrans_correct(
tc_track.data[0].lat.values[i_node:i_node + 2],
tc_track.data[0].lon.values[i_node:i_node + 2],
tc_track.data[0].radius_max_wind.values[i_node],
CENTR_TEST_BRB.coord[:6, :], r_arr)
to_kn = (1 * ureg.meter / ureg.second).to(ureg.knot).magnitude
v_trans = 10.191466256012880 / to_kn
v_trans_corr *= v_trans
self.assertEqual(v_trans_corr.size, 6)
self.assertAlmostEqual(v_trans_corr[0] * to_kn, 0.06547673730228235)
self.assertAlmostEqual(v_trans_corr[1] * to_kn, 0.07106877437273672)
self.assertAlmostEqual(v_trans_corr[2] * to_kn, 0.07641714650288109)
self.assertAlmostEqual(v_trans_corr[3] * to_kn, 0.0627289214278824)
self.assertAlmostEqual(v_trans_corr[4] * to_kn, 0.0697427233582331)
self.assertAlmostEqual(v_trans_corr[5] * to_kn, 0.06855335593983322)
def test_set_one_pass(self):
"""Test _tc_from_track function."""
intensity_idx = [0, 1, 2, 3, 80, 100, 120, 200, 220, 250, 260, 295]
intensity_values = {
"geosphere": [25.60794285, 26.90906280, 28.26649026, 25.54076797, 31.21986961,
36.17171808, 21.11408573, 28.01457948, 32.65349378, 31.34027741, 0,
40.27362679],
"equirect": [25.60778909, 26.90887264, 28.26624642, 25.54092386, 31.21941738,
36.16596567, 21.11399856, 28.01452136, 32.65076804, 31.33884098, 0,
40.27002104]
}
# the values for the two metrics should agree up to first digit at least
for i, val in enumerate(intensity_values["geosphere"]):
self.assertAlmostEqual(intensity_values["equirect"][i], val, 1)
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
tc_track.data = tc_track.data[:1]
for metric in ["equirect", "geosphere"]:
tc_haz = TropCyclone()
tc_haz.set_from_tracks(tc_track, centroids=CENTR_TEST_BRB, model='H08',
store_windfields=True, metric=metric)
self.assertEqual(tc_haz.tag.haz_type, 'TC')
self.assertEqual(tc_haz.tag.description, '')
self.assertEqual(tc_haz.tag.file_name, 'Name: 1951239N12334')
self.assertEqual(tc_haz.units, 'm/s')
self.assertEqual(tc_haz.centroids.size, 296)
self.assertEqual(tc_haz.event_id.size, 1)
self.assertEqual(tc_haz.date.size, 1)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).year, 1951)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).month, 8)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).day, 27)
self.assertEqual(tc_haz.event_id[0], 1)
self.assertEqual(tc_haz.event_name, ['1951239N12334'])
self.assertTrue(np.array_equal(tc_haz.frequency, np.array([1])))
self.assertTrue(isinstance(tc_haz.fraction, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.fraction.shape, (1, 296))
self.assertEqual(tc_haz.fraction[0, 100], 1)
self.assertEqual(tc_haz.fraction[0, 260], 0)
self.assertEqual(tc_haz.fraction.nonzero()[0].size, 280)
self.assertTrue(isinstance(tc_haz.intensity, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.intensity.shape, (1, 296))
self.assertEqual(np.nonzero(tc_haz.intensity)[0].size, 280)
for idx, val in zip(intensity_idx, intensity_values[metric]):
if val == 0:
self.assertEqual(tc_haz.intensity[0, idx], 0)
else:
self.assertAlmostEqual(tc_haz.intensity[0, idx], val)
windfields = tc_haz.windfields[0].toarray()
windfields = windfields.reshape(windfields.shape[0], -1, 2)
windfield_norms = np.linalg.norm(windfields, axis=-1).max(axis=0)
intensity = tc_haz.intensity.toarray()[0, :]
msk = (intensity > 0)
np.testing.assert_array_equal(windfield_norms[msk], intensity[msk])
def test_vtrans_correct(self):
""" Test _vtrans_correct function. Compare to MATLAB reference."""
ureg = UnitRegistry()
i_node = 1
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
tc_track.data[0]['radius_max_wind'] = ('time', tc._extra_rad_max_wind(
tc_track.data[0].central_pressure.values,
tc_track.data[0].radius_max_wind.values, ureg))
coast_centr = tc.coastal_centr_idx(CENT_CLB)
new_centr = CENT_CLB.coord[coast_centr]
r_arr = np.array([286.4938638337190, 290.5930935802884,
295.0271327746536, 299.7811253637995,
296.8484825705515, 274.9892882245964])
close_centr = np.array([400381, 400382, 400383, 400384, 401110,
1019665]) - 1
v_trans_corr = tc._vtrans_correct(
tc_track.data[0].lat.values[i_node:i_node+2],
tc_track.data[0].lon.values[i_node:i_node+2],
tc_track.data[0].radius_max_wind.values[i_node],
new_centr[close_centr, :], r_arr)
to_kn = (1* ureg.meter / ureg.second).to(ureg.knot).magnitude
v_trans = 10.191466256012880 / to_kn
v_trans_corr *= v_trans
self.assertEqual(v_trans_corr.size, 6)
self.assertAlmostEqual(v_trans_corr[0] * to_kn, 2.490082696506720)
self.assertAlmostEqual(v_trans_corr[1] * to_kn, 2.418324821762491)
self.assertAlmostEqual(v_trans_corr[2] * to_kn, 2.344175399115656)
self.assertAlmostEqual(v_trans_corr[3] * to_kn, 2.268434724527058)
self.assertAlmostEqual(v_trans_corr[4] * to_kn, 2.416654031976129)
self.assertAlmostEqual(v_trans_corr[5] * to_kn, -1.394485527059995)
def test_calc_land_decay_pass(self):
""" Test _calc_land_decay with environmental pressure function."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TC_ANDREW_FL)
land_geom = tc._calc_land_geom(tc_track.data)
tc._track_land_params(tc_track.data[0], land_geom)
v_rel, p_rel = tc_track._calc_land_decay(land_geom)
self.assertEqual(7, len(v_rel))
for i, val in enumerate(v_rel.values()):
self.assertAlmostEqual(val, 0.0038894834)
self.assertTrue(i + 1 in v_rel.keys())
self.assertEqual(7, len(p_rel))
for i, val in enumerate(p_rel.values()):
self.assertAlmostEqual(val[0], 1.0598491)
self.assertAlmostEqual(val[1], 0.0041949237)
self.assertTrue(i + 1 in p_rel.keys())
def test_wrong_decay_pass(self):
""" Test decay not implemented when coefficient < 1 """
track = TCTracks()
track.read_ibtracs_netcdf(provider='usa', storm_id='1975178N28281')
track_gen = track.data[0]
track_gen['lat'] = np.array([28.20340431, 28.7915261 , 29.38642458, 29.97836984, 30.56844404,
31.16265292, 31.74820301, 32.34449825, 32.92261894, 33.47430891,
34.01492525, 34.56789399, 35.08810845, 35.55965893, 35.94835174,
36.29355848, 36.45379561, 36.32473812, 36.07552209, 35.92224784,
35.84144186, 35.78298537, 35.86090718, 36.02440372, 36.37555559,
37.06207765, 37.73197352, 37.97524273, 38.05560287, 38.21901208,
38.31486156, 38.30813367, 38.28481808, 38.28410366, 38.25894812,
38.20583372, 38.22741099, 38.39970022, 38.68367797, 39.08329904,
39.41434629, 39.424984 , 39.31327716, 39.30336335, 39.31714429,
39.27031932, 39.30848775, 39.48759833, 39.73326595, 39.96187967,
40.26954226, 40.76882202, 41.40398607, 41.93809726, 42.60395785,
43.57074792, 44.63816143, 45.61450458, 46.68528511, 47.89209365,
49.15580502])
track_gen['lon'] = np.array([-79.20514075, -79.25243311, -79.28393082, -79.32324646,
-79.36668585, -79.41495519, -79.45198688, -79.40580325,
-79.34965443, -79.36938122, -79.30294825, -79.06809546,
-78.70281969, -78.29418936, -77.82170609, -77.30034709,
-76.79004969, -76.37038827, -75.98641014, -75.58383356,
-75.18310414, -74.7974524 , -74.3797645 , -73.86393572,
-73.37910948, -73.01059003, -72.77051313, -72.68011328,
-72.66864779, -72.62579773, -72.56307717, -72.46607618,
-72.35871353, -72.31120649, -72.15537583, -71.75577051,
-71.25287498, -70.75527907, -70.34788946, -70.17518421,
-70.04446577, -69.76582749, -69.44372386, -69.15881376,
-68.84351922, -68.47890287, -68.04184565, -67.53541437,
-66.94008642, -66.25596075, -65.53496635, -64.83491802,
-64.12962685, -63.54118808, -62.72934383, -61.34915091,
-59.72580755, -58.24404252, -56.71972992, -55.0809336 ,
-53.31524758])
v_rel = {3: 0.002249541544102336, 1: 0.00046889526284203036, 4: 0.002649273787364977, 2: 0.0016426186150461349, 5: 0.00246400811445618, 7: 0.0030442198547309075, 6: 0.002346537842810565}
p_rel = {3: (1.028420239620591, 0.003174733355067952), 1: (1.0046803184177564, 0.0007997633912500546), 4: (1.0498749735343516, 0.0034665588904747515), 2: (1.0140127424090262, 0.002131858515233042), 5: (1.0619445995372885, 0.003467268426139696), 7: (1.0894914184297835, 0.004315034379018768), 6: (1.0714354641894077, 0.002783787561718677)}
track_gen.attrs['orig_event_flag'] = False
cp_ref = np.array([1012., 1012.])
land_geom = _calc_land_geom([track_gen])
track_res = _apply_decay_coeffs(track_gen, v_rel, p_rel, land_geom, True)
self.assertTrue(np.array_equal(cp_ref, track_res.central_pressure[9:11]))
def test_dist_since_lf_pass(self):
""" Test _dist_since_lf for andrew tropical cyclone."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TC_ANDREW_FL)
track = tc_track.get_track()
track['on_land'] = ('time', coord_on_land(track.lat.values,
track.lon.values))
track['dist_since_lf'] = ('time', tc._dist_since_lf(track))
self.assertTrue(np.all(np.isnan(track.dist_since_lf.values[track.on_land == False])))
self.assertEqual(track.dist_since_lf.values[track.on_land == False].size, 38)
self.assertTrue(track.dist_since_lf.values[-1] >
dist_to_coast(track.lat.values[-1], track.lon.values[-1])/1000)
self.assertEqual(1020.5431562223974, track['dist_since_lf'].values[-1])
# check distances on land always increase, in second landfall
dist_on_land = track.dist_since_lf.values[track.on_land]
self.assertTrue(np.all(np.diff(dist_on_land)[1:] > 0))
def test_filter_ibtracs_year_basin_pass(self):
""" Test _filter_ibtracs """
fn_nc = os.path.join(os.path.abspath(SYSTEM_DIR), 'IBTrACS.ALL.v04r00.nc')
tc_track = TCTracks()
sel = tc_track._filter_ibtracs(fn_nc, storm_id=None, year_range=(1915, 1916),
basin='WP')
nc_data=Dataset(fn_nc)
for i_sel in sel:
self.assertEqual('WP',
''.join(nc_data.variables['basin'][i_sel, 0, :].astype(str)))
isot = nc_data.variables['iso_time'][i_sel, :, :]
val_len = isot.mask[isot.mask==False].shape[0]//isot.shape[1]
date = isot.data[:val_len]
year = dt.datetime.strptime(''.join(date[0].astype(str)), '%Y-%m-%d %H:%M:%S').year
self.assertTrue(year <= 1915 or year >= 1916)
self.assertEqual(sel.size, 48)
def test_penv_pass(self):
""" Test _set_penv method."""
tc_track = TCTracks()
basin = 'US'
self.assertEqual(tc_track._set_penv(basin), 1010)
basin = 'NA'
self.assertEqual(tc_track._set_penv(basin), 1010)
basin = 'SA'
self.assertEqual(tc_track._set_penv(basin), 1010)
basin = 'NI'
self.assertEqual(tc_track._set_penv(basin), 1005)
basin = 'SI'
self.assertEqual(tc_track._set_penv(basin), 1005)
basin = 'SP'
self.assertEqual(tc_track._set_penv(basin), 1004)
basin = 'WP'
self.assertEqual(tc_track._set_penv(basin), 1005)
basin = 'EP'
self.assertEqual(tc_track._set_penv(basin), 1010)
def test_set_one_pass(self):
"""Test _tc_from_track function."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
tc_track.data = tc_track.data[:1]
tc_haz = TropCyclone()
tc_haz.set_from_tracks(tc_track,
centroids=CENTR_TEST_BRB,
model='H08',
store_windfields=True)
self.assertEqual(tc_haz.tag.haz_type, 'TC')
self.assertEqual(tc_haz.tag.description, '')
self.assertEqual(tc_haz.tag.file_name, 'Name: 1951239N12334')
self.assertEqual(tc_haz.units, 'm/s')
self.assertEqual(tc_haz.centroids.size, 296)
self.assertEqual(tc_haz.event_id.size, 1)
self.assertEqual(tc_haz.date.size, 1)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).year, 1951)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).month, 8)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).day, 27)
self.assertEqual(tc_haz.event_id[0], 1)
self.assertEqual(tc_haz.event_name, ['1951239N12334'])
self.assertTrue(np.array_equal(tc_haz.frequency, np.array([1])))
self.assertTrue(isinstance(tc_haz.fraction, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.fraction.shape, (1, 296))
self.assertEqual(tc_haz.fraction[0, 100], 1)
self.assertEqual(tc_haz.fraction[0, 260], 0)
self.assertEqual(tc_haz.fraction.nonzero()[0].size, 280)
self.assertTrue(isinstance(tc_haz.intensity, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.intensity.shape, (1, 296))
self.assertEqual(np.nonzero(tc_haz.intensity)[0].size, 280)
self.assertEqual(tc_haz.intensity[0, 260], 0)
self.assertAlmostEqual(tc_haz.intensity[0, 1], 27.08333002)
self.assertAlmostEqual(tc_haz.intensity[0, 2], 28.46008202)
self.assertAlmostEqual(tc_haz.intensity[0, 3], 25.70445069)
self.assertAlmostEqual(tc_haz.intensity[0, 100], 36.45564037)
self.assertAlmostEqual(tc_haz.intensity[0, 250], 31.60115745)
self.assertAlmostEqual(tc_haz.intensity[0, 295], 40.62433745)
to_kn = (1.0 * ureg.meter / ureg.second).to(ureg.knot).magnitude
wind = tc_haz.intensity.toarray()[0, :]
self.assertAlmostEqual(wind[0] * to_kn, 50.08492156)
self.assertAlmostEqual(wind[80] * to_kn, 61.13812028)
self.assertAlmostEqual(wind[120] * to_kn, 41.26159439)
self.assertAlmostEqual(wind[200] * to_kn, 54.85572160)
self.assertAlmostEqual(wind[220] * to_kn, 63.99749424)
windfields = tc_haz.windfields[0].toarray()
windfields = windfields.reshape(windfields.shape[0], -1, 2)
windfield_norms = np.linalg.norm(windfields, axis=-1).max(axis=0)
intensity = tc_haz.intensity.toarray()[0, :]
msk = (intensity > 0)
self.assertTrue(np.allclose(windfield_norms[msk], intensity[msk]))
def test_random_no_landfall_pass(self):
""" Test calc_random_walk with decay and no historical tracks with landfall """
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK_SHORT)
with self.assertLogs('climada.hazard.tc_tracks', level='INFO') as cm:
tc_track.calc_random_walk()
self.assertIn('No historical track with landfall.', cm.output[1])
def test_set_one_pass(self):
"""Test _set_from_track function."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
tc_haz = TCRain._set_from_track(tc_track.data[0], CENTR_TEST_BRB)
self.assertEqual(tc_haz.tag.haz_type, 'TR')
self.assertEqual(tc_haz.tag.description, '')
self.assertEqual(tc_haz.tag.file_name, 'IBTrACS: 1951239N12334')
self.assertEqual(tc_haz.units, 'mm')
self.assertEqual(tc_haz.centroids.size, 296)
self.assertEqual(tc_haz.event_id.size, 1)
self.assertEqual(tc_haz.date.size, 1)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).year, 1951)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).month, 8)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).day, 27)
self.assertEqual(tc_haz.event_id[0], 1)
self.assertEqual(tc_haz.event_name, ['1951239N12334'])
self.assertTrue(np.array_equal(tc_haz.frequency, np.array([1])))
self.assertTrue(isinstance(tc_haz.intensity, sparse.csr.csr_matrix))
self.assertTrue(isinstance(tc_haz.fraction, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.intensity.shape, (1, 296))
self.assertEqual(tc_haz.fraction.shape, (1, 296))
self.assertAlmostEqual(tc_haz.intensity[0, 100], 99.7160586771286, 6)
self.assertAlmostEqual(tc_haz.intensity[0, 260], 33.2087621869295)
self.assertEqual(tc_haz.fraction[0, 100], 1)
self.assertEqual(tc_haz.fraction[0, 260], 1)
self.assertEqual(tc_haz.fraction.nonzero()[0].size, 296)
self.assertEqual(tc_haz.intensity.nonzero()[0].size, 296)
def test_read_range(self):
"""Read a several TCs."""
tc_track = TCTracks()
tc_track.read_ibtracs_netcdf(provider='usa',
storm_id=None,
year_range=(1915, 1916),
basin='WP')
self.assertEqual(tc_track.size, 0)
tc_track = TCTracks()
tc_track.read_ibtracs_netcdf(provider='usa',
year_range=(1993, 1994),
basin='EP')
self.assertEqual(tc_track.size, 32)
def test_gust_from_track(self):
""" Test gust_from_track function. Compare to MATLAB reference. """
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK_SHORT)
tc_track.equal_timestep()
intensity = tc.gust_from_track(tc_track.data[0], CENT_CLB, model='H08')
self.assertTrue(isinstance(intensity, sparse.csr.csr_matrix))
self.assertEqual(intensity.shape, (1, 1656093))
self.assertEqual(np.nonzero(intensity)[0].size, 7)
self.assertEqual(intensity[0, 1630273], 0)
self.assertAlmostEqual(intensity[0, 1630272], 18.505998796740347, 5)
self.assertTrue(np.isclose(18.505998796740347, intensity[0, 1630272]))
self.assertAlmostEqual(intensity[0, 1630393], 18.511077471450232, 6)
self.assertTrue(np.isclose(18.511077471450232, intensity[0, 1630393]))
self.assertAlmostEqual(intensity[0, 1630514], 18.297250626663271, 5)
self.assertTrue(np.isclose(18.297250626663271, intensity[0, 1630514]))
self.assertAlmostEqual(intensity[0, 1630635], 17.733240401598668, 6)
self.assertTrue(np.isclose(17.733240401598668, intensity[0, 1630635]))
self.assertAlmostEqual(intensity[0, 1630877], 17.525880201507256, 6)
self.assertTrue(np.isclose(17.525880201507256, intensity[0, 1630877]))
def test_set_one_pass(self):
"""Test _hazard_from_track function."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK_SHORT)
tc_track.equal_timestep()
coastal_centr = tc.coastal_centr_idx(CENT_CLB)
tc_haz = TropCyclone._tc_from_track(tc_track.data[0], CENT_CLB,
coastal_centr)
self.assertEqual(tc_haz.tag.haz_type, 'TC')
self.assertEqual(tc_haz.tag.description, '')
self.assertEqual(tc_haz.tag.file_name, 'IBTrACS: 1951239N12334')
self.assertEqual(tc_haz.units, 'm/s')
self.assertEqual(tc_haz.centroids.size, 1656093)
self.assertEqual(tc_haz.event_id.size, 1)
self.assertEqual(tc_haz.date.size, 1)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).year, 1951)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).month, 8)
self.assertEqual(dt.datetime.fromordinal(tc_haz.date[0]).day, 27)
self.assertEqual(tc_haz.event_id[0], 1)
self.assertEqual(tc_haz.event_name, ['1951239N12334'])
self.assertTrue(np.array_equal(tc_haz.frequency, np.array([1])))
self.assertTrue(isinstance(tc_haz.intensity, sparse.csr.csr_matrix))
self.assertTrue(isinstance(tc_haz.fraction, sparse.csr.csr_matrix))
self.assertEqual(tc_haz.intensity.shape, (1, 1656093))
self.assertEqual(tc_haz.fraction.shape, (1, 1656093))
self.assertAlmostEqual(tc_haz.intensity[0, 1630393],
18.511077471450232, 6)
self.assertEqual(tc_haz.intensity[0, 1630394], 0)
self.assertEqual(tc_haz.fraction[0, 1630393], 1)
self.assertEqual(tc_haz.fraction[0, 1630394], 0)
self.assertEqual(tc_haz.fraction.nonzero()[0].size, 7)
self.assertEqual(tc_haz.intensity.nonzero()[0].size, 7)
def test_interp_track_pass(self):
""" Interpolate track to min_time_step. Compare to MATLAB reference."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep(time_step_h=1)
self.assertEqual(tc_track.data[0].time.size, 223)
self.assertAlmostEqual(tc_track.data[0].lon.values[11],
-27.426151640151684)
self.assertAlmostEqual(tc_track.data[0].lat[23], 12.300006169591480)
self.assertEqual(tc_track.data[0].time_step[7], 1)
self.assertEqual(np.max(tc_track.data[0].radius_max_wind), 0)
self.assertEqual(np.min(tc_track.data[0].radius_max_wind), 0)
self.assertEqual(tc_track.data[0].max_sustained_wind[21], 25)
self.assertAlmostEqual(tc_track.data[0].central_pressure.values[29],
1.005409300000005e+03)
self.assertEqual(np.max(tc_track.data[0].environmental_pressure), 1010)
self.assertEqual(np.min(tc_track.data[0].environmental_pressure), 1010)
self.assertEqual(tc_track.data[0]['time.year'][13], 1951)
self.assertEqual(tc_track.data[0]['time.month'][26], 8)
self.assertEqual(tc_track.data[0]['time.day'][7], 27)
self.assertEqual(tc_track.data[0].max_sustained_wind_unit, 'kn')
self.assertEqual(tc_track.data[0].central_pressure_unit, 'mb')
self.assertEqual(tc_track.data[0].orig_event_flag, 1)
self.assertEqual(tc_track.data[0].name, '1951239N12334')
self.assertEqual(tc_track.data[0].data_provider, 'hurdat_atl')
self.assertTrue(np.isnan(tc_track.data[0].basin))
self.assertEqual(tc_track.data[0].id_no, 1951239012334)
self.assertEqual(tc_track.data[0].category, 1)
def test_vtrans_pass(self):
"""Test _vtrans function. Compare to MATLAB reference."""
tc_track = TCTracks.from_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
v_trans, _ = _vtrans(tc_track.data[0].lat.values,
tc_track.data[0].lon.values,
tc_track.data[0].time_step.values)
to_kn = (1.0 * ureg.meter / ureg.second).to(ureg.knot).magnitude
self.assertEqual(v_trans.size, tc_track.data[0].time.size)
self.assertEqual(v_trans[0], 0)
self.assertAlmostEqual(v_trans[1] * to_kn, 10.191466246)
def test_calc_decay_no_landfall_pass(self):
""" Test _calc_land_decay with no historical tracks with landfall """
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK_SHORT)
land_geom = tc._calc_land_geom(tc_track.data)
tc._track_land_params(tc_track.data[0], land_geom)
with self.assertLogs('climada.hazard.tc_tracks', level='INFO') as cm:
tc_track._calc_land_decay(land_geom)
self.assertIn('No historical track with landfall.', cm.output[0])
def test_apply_decay_no_landfall_pass(self):
""" Test _apply_land_decay with no historical tracks with landfall """
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK_SHORT)
land_geom = tc._calc_land_geom(tc_track.data)
tc._track_land_params(tc_track.data[0], land_geom)
tc_track.data[0]['orig_event_flag']=False
tc_ref = tc_track.data[0].copy()
tc_track._apply_land_decay(dict(), dict(), land_geom)
self.assertTrue(np.array_equal(tc_track.data[0].max_sustained_wind.values, tc_ref.max_sustained_wind.values))
self.assertTrue(np.array_equal(tc_track.data[0].central_pressure.values, tc_ref.central_pressure.values))
self.assertTrue(np.array_equal(tc_track.data[0].environmental_pressure.values, tc_ref.environmental_pressure.values))
self.assertTrue(np.all(np.isnan(tc_track.data[0].dist_since_lf.values)))
def test_rainfield_from_track_pass(self):
"""Test _rainfield_from_track function. Compare to MATLAB reference."""
tc_track = TCTracks()
tc_track.read_processed_ibtracs_csv(TEST_TRACK)
tc_track.equal_timestep()
rainfall = rainfield_from_track(tc_track.data[0], CENTR_TEST_BRB)
rainfall = np.round(rainfall, decimals=9)
self.assertAlmostEqual(rainfall[0, 0], 66.801702386)
self.assertAlmostEqual(rainfall[0, 130], 43.290917792)
self.assertAlmostEqual(rainfall[0, 200], 76.315923838)
